From a7caea34abc09a48d11d00f9957586a7cf3d628f Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 26 Oct 2026 16:58:04 -0700 Subject: [PATCH 1/9] fix(mobile): queued messages are delivered by an app service, not a render loop (#25678) Co-authored-by: Claude Opus 5.5 --- apps/mobile/src/App.tsx | 15 +- apps/mobile/src/Stack.tsx | 10 - .../state/composer-attachment-uploads.test.ts | 43 +- .../src/state/composer-attachment-uploads.ts | 215 +-- apps/mobile/src/state/session.ts | 2 +- ... threadOutboxDelivery.permissions.test.ts} | 194 ++- ...n.test.ts => threadOutboxDelivery.test.ts} | 56 +- ...utbox-drain.ts => threadOutboxDelivery.ts} | 1152 +++++++++-------- apps/mobile/src/state/use-thread-outbox.ts | 6 +- 9 files changed, 923 insertions(+), 770 deletions(-) rename apps/mobile/src/state/{use-thread-outbox-drain.permissions.test.ts => threadOutboxDelivery.permissions.test.ts} (67%) rename apps/mobile/src/state/{use-thread-outbox-drain.test.ts => threadOutboxDelivery.test.ts} (93%) rename apps/mobile/src/state/{use-thread-outbox-drain.ts => threadOutboxDelivery.ts} (55%) diff --git a/apps/mobile/src/App.tsx b/apps/mobile/src/App.tsx index 8dff8bdc50396..2033b45d563d2 100644 --- a/apps/mobile/src/App.tsx +++ b/apps/mobile/src/App.tsx @@ -1,4 +1,6 @@ import { installPermissionUpdateNotice } from "./features/connection/permissionUpdateNotice"; +import { installComposerAttachmentUploads } from "./state/composer-attachment-uploads"; +import { installThreadOutboxDelivery } from "./state/threadOutboxDelivery"; import * as Linking from "expo-linking"; import * as SplashScreen from "expo-splash-screen"; import { useEffect } from "react"; @@ -86,11 +88,14 @@ const navigationRef = createNavigationContainerRef(); declare const module: { readonly hot?: FoundationHotModule } | undefined; -const disposePermissionUpdateNotice = installPermissionUpdateNotice(); -disposeOnFoundationReplace( - typeof module === "undefined" ? undefined : module.hot, - disposePermissionUpdateNotice, -); +const appServiceDisposers = [ + installPermissionUpdateNotice(), + installThreadOutboxDelivery(), + installComposerAttachmentUploads(), +]; +disposeOnFoundationReplace(typeof module === "undefined" ? undefined : module.hot, () => { + for (const dispose of appServiceDisposers) dispose(); +}); function SplashScreenCoordinator() { const { isReady } = useAppearancePreferences(); diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx index ffc4b0bc8de93..fab1f307b04c4 100644 --- a/apps/mobile/src/Stack.tsx +++ b/apps/mobile/src/Stack.tsx @@ -149,8 +149,6 @@ import { deriveLayout } from "./lib/layout"; import { useNativeLayoutMetrics } from "./native/native-layout-metrics"; import { nativeHeaderScrollEdgeEffects } from "./native/StackHeader"; import { HORIZONTAL_FORM_SHEET_OPTIONS, formSheetDetents } from "./native/sheet-surface"; -import { useThreadOutboxDrain } from "./state/use-thread-outbox-drain"; -import { useComposerAttachmentUploadWorker } from "./state/composer-attachment-uploads"; import { selectWorkspaceDetail, workspaceDetailRouter, @@ -485,13 +483,6 @@ function workspaceLocationFromState(state: NavigationState) { }; } -// Isolate subscriptions so streaming updates cannot re-render RootStackLayout and every screen. -function ThreadOutboxDrainWorker() { - useThreadOutboxDrain(); - useComposerAttachmentUploadWorker(); - return null; -} - function RootStackLayout(props: { readonly children: React.ReactNode; readonly state: NavigationState; @@ -546,7 +537,6 @@ function RootStackLayout(props: { routePendingTaskId={routePendingTaskId} > - diff --git a/apps/mobile/src/state/composer-attachment-uploads.test.ts b/apps/mobile/src/state/composer-attachment-uploads.test.ts index fc7a5e47bac53..e549858b00840 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.test.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.test.ts @@ -19,20 +19,9 @@ const native = vi.hoisted(() => ({ remove: Symbol("remove"), transfer: vi.fn<(uri: string, url: string, options: UploadOptions) => Promise<{ status: number }>>(), - effects: [] as Array<() => void | (() => void)>, - queueRef: { - current: null as ReturnType< - typeof import("../lib/composerAttachmentUploadQueue").createComposerAttachmentUploadQueue - > | null, - }, })); vi.mock("react-native", () => ({ Alert: { alert: vi.fn() } })); -vi.mock("react", async (importOriginal) => ({ - ...(await importOriginal()), - useEffect: (effect: () => void | (() => void)) => native.effects.push(effect), - useRef: () => native.queueRef, -})); vi.mock("@effect/atom-react", () => ({ useAtomValue: (atom: Parameters[0]) => appAtomRegistry.get(atom), })); @@ -111,6 +100,8 @@ vi.mock("./entities", () => ({ useServerConfigs: () => new Map([["environment-1", config]]), useThreadShells: () => [], })); +vi.mock("./projects", () => ({ environmentProjects: {} })); +vi.mock("./workspace", () => ({ workspaceConnections: {} })); vi.mock("./server", async () => { const { Atom } = await import("effect/reactivity"); return { serverEnvironment: { configValueAtom: Atom.family(() => Atom.make(null)) } }; @@ -173,14 +164,9 @@ vi.mock("./use-thread-outbox", async () => { dispatchingQueuedMessageIdAtom: Atom.make>({}).pipe(Atom.keepAlive), useThreadOutboxMessages: () => appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), - useThreadOutboxShellStatuses: () => new Map(), + threadOutboxShellStatusesAtom: Atom.make(new Map()), }; }); -vi.mock("./use-remote-environment-registry", () => ({ - useRemoteConnectionStatus: () => ({ - connectedEnvironments: [{ environmentId: "environment-1", connectionState: "connected" }], - }), -})); import { composerAttachmentUploadBlockReason, @@ -188,10 +174,12 @@ import { composerAttachmentUploadKey, } from "../lib/composerAttachmentUploadQueue"; import type { DraftComposerAttachment } from "../lib/composerImages"; +import { Atom } from "effect/reactivity"; import { appAtomRegistry } from "./atom-registry"; import { + composerAttachmentUploadRequests, composerAttachmentUploadsAtom, - useComposerAttachmentUploadWorker, + createComposerAttachmentUploadWorker, } from "./composer-attachment-uploads"; import { enqueueThreadOutboxMessage, @@ -200,7 +188,7 @@ import { } from "./thread-outbox"; import type { QueuedThreadMessage } from "./thread-outbox-model"; import * as drafts from "./use-composer-drafts"; -import { prepareQueuedMessageAttachments } from "./use-thread-outbox-drain"; +import { prepareQueuedMessageAttachments } from "./threadOutboxDelivery"; const environmentId = EnvironmentId.make("environment-1"); const draftKey = "environment-1:thread-1"; @@ -217,12 +205,19 @@ const image: DraftComposerAttachment = { }; let disposeWorker: (() => void) | undefined; +const requestsAtom = Atom.make((get) => + composerAttachmentUploadRequests({ + drafts: get(drafts.composerDraftUploadSourcesAtom), + queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom), + connectedEnvironmentIds: new Set([environmentId]), + operableEnvironmentIds: new Set([environmentId]), + serverConfigs: new Map([[environmentId, config]]), + }), +); + function worker() { - native.effects = []; - useComposerAttachmentUploadWorker(); - disposeWorker = native.effects[0]!() ?? undefined; - const queue = native.queueRef.current!; - native.effects[1]!(); + const { queue, dispose } = createComposerAttachmentUploadWorker(requestsAtom); + disposeWorker = dispose; return queue; } diff --git a/apps/mobile/src/state/composer-attachment-uploads.ts b/apps/mobile/src/state/composer-attachment-uploads.ts index 0e543ffe18349..7bf7747fef2c7 100644 --- a/apps/mobile/src/state/composer-attachment-uploads.ts +++ b/apps/mobile/src/state/composer-attachment-uploads.ts @@ -2,11 +2,13 @@ import { settlePromise, squashAtomCommandFailure } from "@t3tools/client-runtime import { useAtomValue } from "@effect/atom-react"; import { AuthOrchestrationOperateScope, type EnvironmentId } from "@t3tools/contracts"; import { Atom, AsyncResult } from "effect/reactivity"; -import { useEffect, useRef } from "react"; import { prepareTurnAttachments } from "../lib/attachmentUpload"; import { retainComposerAttachmentFileForPreview } from "../lib/composerAttachmentPreviewRetention"; -import { isFileBackedComposerAttachment } from "../lib/composerImages"; +import { + isFileBackedComposerAttachment, + type DraftComposerAttachment, +} from "../lib/composerImages"; import { composerAttachmentUploadKey, composerDraftEnvironmentId, @@ -15,19 +17,19 @@ import { type ComposerAttachmentUploadState, } from "../lib/composerAttachmentUploadQueue"; import { appAtomRegistry } from "./atom-registry"; -import { useServerConfigs } from "./entities"; +import { environmentServerConfigsAtom } from "./server"; import { flattenQueuedThreadMessages, threadOutboxManager } from "./thread-outbox"; -import { useThreadOutboxMessages } from "./use-thread-outbox"; import { ComposerDraftPersistenceError, + type ComposerDraft, composerDraftsAtom, composerDraftUploadSourcesAtom, ensureComposerDraftsLoaded, flushComposerDrafts, setComposerDraftAttachmentUpload, } from "./use-composer-drafts"; -import { useRemoteConnectionStatus } from "./use-remote-environment-registry"; -import { readEnvironmentScope, useEnvironmentsWithScope } from "./session"; +import { environmentSession, readEnvironmentScope, sessionHasScope } from "./session"; +import { workspaceConnections } from "./workspace"; export { composerAttachmentUploadBlockReason, @@ -56,91 +58,130 @@ export function retryComposerAttachmentUpload(environmentId: EnvironmentId, atta uploadQueue?.retry(environmentId, attachmentId); } -export function useComposerAttachmentUploadWorker() { - const drafts = useAtomValue(composerDraftUploadSourcesAtom); - const queuedMessages = useThreadOutboxMessages(); - const serverConfigs = useServerConfigs(); - const { connectedEnvironments } = useRemoteConnectionStatus(); - const operableEnvironments = useEnvironmentsWithScope( - connectedEnvironments, - AuthOrchestrationOperateScope, +type ComposerAttachmentUploadRequest = { + readonly environmentId: EnvironmentId; + readonly attachment: DraftComposerAttachment; +}; + +export function composerAttachmentUploadRequests(input: { + readonly drafts: Readonly>>; + readonly queuedMessagesByThreadKey: Parameters[0]; + readonly connectedEnvironmentIds: ReadonlySet; + readonly operableEnvironmentIds: ReadonlySet; + readonly serverConfigs: ReadonlyMap< + EnvironmentId, + Parameters[1] + >; +}): ReadonlyArray { + const queued = flattenQueuedThreadMessages(input.queuedMessagesByThreadKey); + return Object.entries(input.drafts).flatMap(([key, draft]) => { + const environmentId = composerDraftEnvironmentId(key, queued, draft); + if ( + environmentId === null || + !input.connectedEnvironmentIds.has(environmentId) || + !input.operableEnvironmentIds.has(environmentId) + ) + return []; + return draft.attachments + .filter((attachment) => + canUploadComposerAttachment(attachment, input.serverConfigs.get(environmentId)), + ) + .map((attachment) => ({ environmentId, attachment })); + }); +} + +// Each connected environment's session is read here so a granted or revoked +// operate scope re-syncs the queue. +const composerAttachmentUploadRequestsAtom = Atom.make((get) => { + const connected = get(workspaceConnections.environmentsAtom).filter( + (environment) => environment.connectionState === "connected", ); - const queueRef = useRef | null>(null); + const operableEnvironmentIds = new Set(); + for (const { environmentId } of connected) { + if ( + sessionHasScope( + get(environmentSession.sessionStateAtom(environmentId)), + AuthOrchestrationOperateScope, + ) + ) { + operableEnvironmentIds.add(environmentId); + } + } + return composerAttachmentUploadRequests({ + drafts: get(composerDraftUploadSourcesAtom), + queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom), + connectedEnvironmentIds: new Set(connected.map((environment) => environment.environmentId)), + operableEnvironmentIds, + serverConfigs: get(environmentServerConfigsAtom), + }); +}).pipe(Atom.withLabel("mobile:composer-attachment-upload-requests")); - useEffect(() => { - ensureComposerDraftsLoaded(); - const queue = createComposerAttachmentUploadQueue({ - onChange: (states) => appAtomRegistry.set(composerAttachmentUploadsAtom, states), - upload: async ({ environmentId, attachment }, signal, onProgress) => { - const release = isFileBackedComposerAttachment(attachment) - ? retainComposerAttachmentFileForPreview(attachment) - : undefined; - const prepared = await settlePromise(() => - prepareTurnAttachments({ - environmentId, - attachments: [attachment], - supportsImageUploads: true, - signal, - onUploadProgress: (_, progress) => onProgress(progress), - persistUploadedReferences: async ([uploaded]) => { - if (signal.aborted || !uploaded) return "abandon"; - const queued = flattenQueuedThreadMessages( - appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), - ); - let retained = false; - for (const [key, draft] of Object.entries(appAtomRegistry.get(composerDraftsAtom))) { - if ( - composerDraftEnvironmentId(key, queued, draft) === environmentId && - draft.attachments.some((candidate) => candidate.id === attachment.id) - ) { - retained = setComposerDraftAttachmentUpload(key, uploaded) || retained; - } +/** + * Uploads draft attachments to their environment as soon as it is connected and + * operable. The queue follows the requests atom for its whole lifetime. + */ +export function createComposerAttachmentUploadWorker( + requestsAtom: Atom.Atom< + ReadonlyArray + > = composerAttachmentUploadRequestsAtom, +) { + ensureComposerDraftsLoaded(); + const queue = createComposerAttachmentUploadQueue({ + onChange: (states) => appAtomRegistry.set(composerAttachmentUploadsAtom, states), + upload: async ({ environmentId, attachment }, signal, onProgress) => { + const release = isFileBackedComposerAttachment(attachment) + ? retainComposerAttachmentFileForPreview(attachment) + : undefined; + const prepared = await settlePromise(() => + prepareTurnAttachments({ + environmentId, + attachments: [attachment], + supportsImageUploads: true, + signal, + onUploadProgress: (_, progress) => onProgress(progress), + persistUploadedReferences: async ([uploaded]) => { + if (signal.aborted || !uploaded) return "abandon"; + const queued = flattenQueuedThreadMessages( + appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), + ); + let retained = false; + for (const [key, draft] of Object.entries(appAtomRegistry.get(composerDraftsAtom))) { + if ( + composerDraftEnvironmentId(key, queued, draft) === environmentId && + draft.attachments.some((candidate) => candidate.id === attachment.id) + ) { + retained = setComposerDraftAttachmentUpload(key, uploaded) || retained; } - if (!retained) return "abandon"; - // Draft-save failure only costs re-upload after restart; the outbox saves references independently, so preserve accepted uploads. - await flushComposerDrafts().catch((error: unknown) => { - if (!(error instanceof ComposerDraftPersistenceError)) throw error; - console.warn("[composer-attachments] could not save the uploaded reference", error); - }); - return "persisted"; - }, - }), - ); - release?.(); - if (AsyncResult.isFailure(prepared)) throw squashAtomCommandFailure(prepared); - return prepared.value.status === "ready"; - }, - }); - queueRef.current = queue; - uploadQueue = queue; - return () => { + } + if (!retained) return "abandon"; + // Draft-save failure only costs re-upload after restart; the outbox saves references independently, so preserve accepted uploads. + await flushComposerDrafts().catch((error: unknown) => { + if (!(error instanceof ComposerDraftPersistenceError)) throw error; + console.warn("[composer-attachments] could not save the uploaded reference", error); + }); + return "persisted"; + }, + }), + ); + release?.(); + if (AsyncResult.isFailure(prepared)) throw squashAtomCommandFailure(prepared); + return prepared.value.status === "ready"; + }, + }); + uploadQueue = queue; + const unsubscribe = appAtomRegistry.subscribe(requestsAtom, (requests) => queue.sync(requests), { + immediate: true, + }); + return { + queue, + dispose: () => { + unsubscribe(); queue.dispose(); if (uploadQueue === queue) uploadQueue = null; - queueRef.current = null; - }; - }, []); + }, + }; +} - useEffect(() => { - const queued = flattenQueuedThreadMessages(queuedMessages); - const connected = new Set( - connectedEnvironments - .filter((environment) => environment.connectionState === "connected") - .map((environment) => environment.environmentId), - ); - const requests = Object.entries(drafts).flatMap(([key, draft]) => { - const environmentId = composerDraftEnvironmentId(key, queued, draft); - if ( - environmentId === null || - !connected.has(environmentId) || - !operableEnvironments.has(environmentId) - ) - return []; - return draft.attachments - .filter((attachment) => - canUploadComposerAttachment(attachment, serverConfigs.get(environmentId)), - ) - .map((attachment) => ({ environmentId, attachment })); - }); - queueRef.current?.sync(requests); - }, [connectedEnvironments, drafts, operableEnvironments, queuedMessages, serverConfigs]); +export function installComposerAttachmentUploads(): () => void { + return createComposerAttachmentUploadWorker().dispose; } diff --git a/apps/mobile/src/state/session.ts b/apps/mobile/src/state/session.ts index ead11793f6a42..010325dfe722a 100644 --- a/apps/mobile/src/state/session.ts +++ b/apps/mobile/src/state/session.ts @@ -17,7 +17,7 @@ export const environmentSession = createEnvironmentSessionAtoms(connectionAtomRu const EMPTY_SESSION_STATE_ATOM = Atom.make(AsyncResult.initial()); -function sessionHasScope( +export function sessionHasScope( result: AsyncResult.AsyncResult, scope: AuthEnvironmentScope, ): boolean { diff --git a/apps/mobile/src/state/use-thread-outbox-drain.permissions.test.ts b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts similarity index 67% rename from apps/mobile/src/state/use-thread-outbox-drain.permissions.test.ts rename to apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts index f199616d43c46..edc80c5007024 100644 --- a/apps/mobile/src/state/use-thread-outbox-drain.permissions.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.permissions.test.ts @@ -13,15 +13,21 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test" import type { QueuedThreadMessage } from "./thread-outbox-model"; const state = vi.hoisted(() => ({ - grantedEnvironments: new Set(), draftText: "Keep this draft separate", cleanups: [] as Array<() => void>, + delivery: null as { + readonly drain: () => void; + readonly dispose: () => void; + } | null, start: vi.fn(), metadata: vi.fn(), runtime: vi.fn(), interaction: vi.fn(), prepare: vi.fn(), checkout: vi.fn(), + modelUnavailable: vi.fn(() => false), + familyMount: vi.fn(() => () => {}), + threadShells: null as unknown as Atom.Writable>, manager: null as unknown as ReturnType< typeof import("./thread-outbox-manager").createThreadOutboxManager >, @@ -34,42 +40,53 @@ const state = vi.hoisted(() => ({ session: null, }, config: { + shellThreadFamilies: false, providers: [{ instanceId: "codex", driver: "codex" }], environment: { capabilities: {} }, }, })); -vi.mock("react", () => ({ - useCallback: (callback: A) => callback, - useEffect: (effect: () => void | (() => void)) => { - const cleanup = effect(); - if (cleanup) state.cleanups.push(cleanup); - }, - useRef: (value: A) => ({ current: value }), - useState: (initial: A) => [initial, vi.fn()], -})); vi.mock("react-native", () => ({ Alert: { alert: vi.fn() } })); -vi.mock("@effect/atom-react", async () => { +vi.mock("@t3tools/client-runtime/state/runtime", async (importOriginal) => ({ + ...(await importOriginal()), + runAtomCommand: (_registry: unknown, command: (input: unknown) => unknown, input: unknown) => + command(input), +})); +vi.mock("./session", async () => { + const { Atom } = await import("effect/reactivity"); const { appAtomRegistry } = await import("./atom-registry"); - return { useAtomValue: (atom: Atom.Atom) => appAtomRegistry.get(atom) }; + // A session's state is reduced to whether it grants the operate scope. + const sessionStateAtom = Atom.family((_id: string) => Atom.make(false).pipe(Atom.keepAlive)); + const sessionHasScope = (granted: boolean, scope: string) => + granted && scope === AuthOrchestrationOperateScope; + return { + environmentSession: { sessionStateAtom }, + sessionHasScope, + readEnvironmentScope: (environmentId: string, scope: string) => + sessionHasScope(appAtomRegistry.get(sessionStateAtom(environmentId)), scope), + }; +}); +vi.mock("./projects", async () => { + const { Atom } = await import("effect/reactivity"); + return { environmentProjects: { projectsAtom: Atom.make([]) } }; +}); +vi.mock("./workspace", async () => { + const { Atom } = await import("effect/reactivity"); + return { + workspaceConnections: { + environmentsAtom: Atom.make([{ environmentId: "secondary", connectionState: "connected" }]), + }, + }; }); -vi.mock("./session", () => ({ - readEnvironmentScope: (environmentId: string, scope: string) => - scope === AuthOrchestrationOperateScope && state.grantedEnvironments.has(environmentId), - useEnvironmentsWithScope: () => state.grantedEnvironments, -})); -vi.mock("./entities", () => ({ - useProjects: () => [], - useThreadShells: () => [state.thread], - useServerConfigs: () => new Map([["secondary", state.config]]), -})); vi.mock("./server", async () => { const { Atom } = await import("effect/reactivity"); return { serverEnvironment: { configValueAtom: Atom.family((_id: string) => Atom.make(state.config)) }, + environmentServerConfigsAtom: Atom.make(new Map([["secondary", state.config]])), }; }); vi.mock("./threads", async () => { - const { Atom } = await import("effect/reactivity"); + const { Atom, AsyncResult } = await import("effect/reactivity"); + state.threadShells = Atom.make>([state.thread]).pipe(Atom.keepAlive); return { threadEnvironment: { startTurn: state.start, @@ -77,21 +94,19 @@ vi.mock("./threads", async () => { setRuntimeMode: state.runtime, setInteractionMode: state.interaction, }, - environmentThreadShells: { threadShellsAtom: Atom.make([state.thread]) }, - environmentThreadDetails: { threadAtom: Atom.family((_key: unknown) => Atom.make(null)) }, + environmentThreadShells: { threadShellsAtom: state.threadShells }, + threadFamilies: { + mount: state.familyMount, + familyAtom: () => Atom.make(AsyncResult.success({})), + refresh: vi.fn(), + }, + environmentThreadDetails: { threadAtom: () => Atom.make(null) }, }; }); -vi.mock("./use-atom-command", () => ({ useAtomCommand: (command: A) => command })); vi.mock("./git", () => ({ gitEnvironment: { preparePullRequestThread: state.checkout } })); -vi.mock("../lib/modelOptions", () => ({ isModelSelectionUnavailable: () => false })); +vi.mock("../lib/modelOptions", () => ({ isModelSelectionUnavailable: state.modelUnavailable })); vi.mock("../lib/uuid", () => ({ uuidv4: () => "uuid", randomHex: () => "abcd" })); vi.mock("../lib/attachmentUpload", () => ({ prepareTurnAttachments: state.prepare })); -vi.mock("./use-remote-environment-registry", () => ({ - setPendingConnectionError: vi.fn(), - useRemoteConnectionStatus: () => ({ - connectedEnvironments: [{ environmentId: "secondary", connectionState: "connected" }], - }), -})); vi.mock("./thread-outbox", async () => { const { createThreadOutboxManager } = await import("./thread-outbox-manager"); const { appAtomRegistry } = await import("./atom-registry"); @@ -118,13 +133,10 @@ vi.mock("./thread-outbox-removal", () => ({ })); vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); - const { appAtomRegistry } = await import("./atom-registry"); - await import("./thread-outbox"); return { editingQueuedMessageIdsAtom: Atom.make({}).pipe(Atom.keepAlive), dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive), - useThreadOutboxMessages: () => appAtomRegistry.get(state.manager.queuedMessagesByThreadKeyAtom), - useThreadOutboxShellStatuses: () => new Map([["secondary", "live"]]), + threadOutboxShellStatusesAtom: Atom.make(new Map([["secondary", "live"]])), }; }); vi.mock("./use-composer-drafts", async () => { @@ -146,8 +158,9 @@ vi.mock("./use-composer-drafts", async () => { }); import { appAtomRegistry } from "./atom-registry"; -import { dispatchingQueuedMessageIdAtom } from "./use-thread-outbox"; -import { useThreadOutboxDrain } from "./use-thread-outbox-drain"; +import { environmentSession } from "./session"; +import { dispatchingQueuedMessageIdAtom, editingQueuedMessageIdsAtom } from "./use-thread-outbox"; +import { createThreadOutboxDelivery } from "./threadOutboxDelivery"; const message = (overrides: Partial = {}): QueuedThreadMessage => ({ environmentId: EnvironmentId.make("secondary"), @@ -162,20 +175,46 @@ const message = (overrides: Partial = {}): QueuedThreadMess const remaining = () => Object.values(appAtomRegistry.get(state.manager.queuedMessagesByThreadKeyAtom)).flat(); +function setOperateGrant(environmentId: string, granted: boolean): void { + // The mocked session atom holds the grant itself (see the ./session mock). + const sessionAtom = environmentSession.sessionStateAtom(EnvironmentId.make(environmentId)); + appAtomRegistry.set(sessionAtom as unknown as Atom.Writable, granted); +} + function runDrain() { const settled = Promise.withResolvers(); const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { if (id === null) settled.resolve(); }); - useThreadOutboxDrain(); + startDelivery(); return settled.promise.finally(release); } +/** Starts the service once per test; later calls run another drain pass. */ +function startDelivery(): void { + if (state.delivery !== null) { + state.delivery.drain(); + return; + } + const delivery = createThreadOutboxDelivery(); + state.delivery = delivery; + state.cleanups.push(() => { + delivery.dispose(); + state.delivery = null; + }); +} + beforeEach(() => { - state.grantedEnvironments = new Set(["primary"]); + setOperateGrant("primary", true); + setOperateGrant("secondary", false); state.draftText = "Keep this draft separate"; + state.config.shellThreadFamilies = false; + state.modelUnavailable.mockReset().mockReturnValue(false); + state.familyMount.mockReset().mockReturnValue(() => {}); + appAtomRegistry.set(state.threadShells, [state.thread]); appAtomRegistry.set(state.manager.queuedMessagesByThreadKeyAtom, {}); appAtomRegistry.set(dispatchingQueuedMessageIdAtom, null); + appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); for (const command of [ state.start, state.metadata, @@ -214,7 +253,7 @@ describe("queued PR checkout", () => { }; it("waits for the provider's PR checkout and launches in that worktree", async () => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); await state.manager.enqueue(queuedPullRequest()); const started = Promise.withResolvers(); const checkout = @@ -243,7 +282,7 @@ describe("queued PR checkout", () => { }); it("keeps the PR source queued on a transport failure without starting the agent", async () => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); const queued = queuedPullRequest(); await state.manager.enqueue(queued); state.checkout.mockResolvedValueOnce( @@ -255,11 +294,11 @@ describe("queued PR checkout", () => { }); it("stops launch if operation access is revoked while checking out the PR", async () => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); const queued = queuedPullRequest(); await state.manager.enqueue(queued); state.checkout.mockImplementationOnce(async () => { - state.grantedEnvironments.delete("secondary"); + setOperateGrant("secondary", false); return AsyncResult.success(preparedCheckout); }); await runDrain(); @@ -268,7 +307,7 @@ describe("queued PR checkout", () => { }); it("does not launch a stale task edited while the PR checkout was running", async () => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); const queued = queuedPullRequest(); await state.manager.enqueue(queued); const edited = { ...queued, text: "Updated instructions" }; @@ -289,18 +328,63 @@ describe("queued task operation access", () => { it("parks a connected read-only target, then delivers its unchanged queue after a grant", async () => { const queued = message(); await state.manager.enqueue(queued); - useThreadOutboxDrain(); + startDelivery(); expect(state.start).not.toHaveBeenCalled(); expect(state.prepare).not.toHaveBeenCalled(); expect(remaining()).toEqual([queued]); - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); + await runDrain(); + expect(state.start).toHaveBeenCalledOnce(); + expect(remaining()).toEqual([]); + }); + + it("backs off instead of redelivering at once when a delivery hits a defect", async () => { + setOperateGrant("secondary", true); + const queued = message(); + await state.manager.enqueue(queued); + // Awaited steps catch their own failures, so a defect in the delivery's own code is what + // rejects a delivery. + state.modelUnavailable.mockImplementationOnce(() => { + throw new TypeError("Cannot read properties of undefined"); + }); await runDrain(); + expect(state.modelUnavailable).toHaveBeenCalledOnce(); + expect(state.prepare).not.toHaveBeenCalled(); + expect(state.start).not.toHaveBeenCalled(); + expect(appAtomRegistry.get(dispatchingQueuedMessageIdAtom)).toBeNull(); + expect(remaining()).toEqual([queued]); + }); + + it("starts one delivery when mounting a thread family changes the rows mid-pass", async () => { + setOperateGrant("secondary", true); + state.config.shellThreadFamilies = true; + const subAgentThread = { ...state.thread, id: "sub-agent" }; + // A cached family merges its rows into the shell list as soon as it is mounted. + state.familyMount.mockImplementationOnce(() => { + appAtomRegistry.set(state.threadShells, [state.thread, subAgentThread]); + return () => {}; + }); + const queued = message({ threadId: ThreadId.make("sub-agent") }); + startDelivery(); + appAtomRegistry.set(editingQueuedMessageIdsAtom, { [queued.messageId]: true }); + await state.manager.enqueue(queued); + using confirm = vi.spyOn(state.manager, "confirmQueued"); + const delivered = Promise.withResolvers(); + const release = appAtomRegistry.subscribe(dispatchingQueuedMessageIdAtom, (id) => { + if (id === null) delivered.resolve(); + }); + // Ending the edit wakes the drain through a registry notification, the path on which the + // mount's synchronous row change notifies the drain again mid-pass. + appAtomRegistry.set(editingQueuedMessageIdsAtom, {}); + expect(state.familyMount).toHaveBeenCalledOnce(); + expect(confirm).toHaveBeenCalledOnce(); + await delivered.promise.finally(release); expect(state.start).toHaveBeenCalledOnce(); expect(remaining()).toEqual([]); }); it("stops the remaining settings and turn commands when an earlier update loses access", async () => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); const queued = message({ modelSelection: { instanceId: ProviderInstanceId.make("codex"), model: "different-model" }, runtimeMode: "approval-required", @@ -308,7 +392,7 @@ describe("queued task operation access", () => { }); await state.manager.enqueue(queued); state.runtime.mockImplementationOnce(async () => { - state.grantedEnvironments.delete("secondary"); + setOperateGrant("secondary", false); return AsyncResult.success(undefined); }); await runDrain(); @@ -325,7 +409,7 @@ describe("queued task operation access", () => { ])( "preserves a rejected queue but removes an accepted turn after access loss (new task: $isCreation, accepted: $accepted)", async ({ isCreation, accepted }) => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); const queued = message( isCreation ? { @@ -350,7 +434,7 @@ describe("queued task operation access", () => { }); const drained = runDrain(); await started.promise; - state.grantedEnvironments.delete("secondary"); + setOperateGrant("secondary", false); delivery.resolve( accepted ? AsyncResult.success(undefined) @@ -361,7 +445,7 @@ describe("queued task operation access", () => { expect(remaining()).toEqual(accepted ? [] : [queued]); expect(state.draftText).toBe("Keep this draft separate"); if (!accepted) { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); await runDrain(); expect(state.start).toHaveBeenCalledTimes(2); expect(remaining()).toEqual([]); @@ -378,7 +462,7 @@ describe("queued task operation access", () => { ])( "keeps the message queued after upload revocation (new task: $isCreation, upload fails: $uploadFails)", async ({ isCreation, uploadFails }) => { - state.grantedEnvironments.add("secondary"); + setOperateGrant("secondary", true); const queued = message( isCreation ? { @@ -396,7 +480,7 @@ describe("queued task operation access", () => { ); await state.manager.enqueue(queued); state.prepare.mockImplementationOnce(async ({ attachments }) => { - state.grantedEnvironments.delete("secondary"); + setOperateGrant("secondary", false); if (uploadFails) throw new Error("This connection cannot upload attachments."); return { status: "ready", diff --git a/apps/mobile/src/state/use-thread-outbox-drain.test.ts b/apps/mobile/src/state/threadOutboxDelivery.test.ts similarity index 93% rename from apps/mobile/src/state/use-thread-outbox-drain.test.ts rename to apps/mobile/src/state/threadOutboxDelivery.test.ts index c4968d3e33e89..901ffaa9e8291 100644 --- a/apps/mobile/src/state/use-thread-outbox-drain.test.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.test.ts @@ -13,6 +13,9 @@ import type { PreparedTurnAttachments } from "../lib/attachmentUpload"; const harness = vi.hoisted(() => ({ canOperate: true, + threadProjection: null as unknown as import("effect/reactivity").Atom.Writable<{ + readonly projection: { readonly messages: ReadonlyArray<{ readonly id: string }> }; + } | null>, manager: null as unknown as ReturnType< typeof import("./thread-outbox-manager").createThreadOutboxManager >, @@ -76,11 +79,9 @@ vi.mock("../lib/attachmentUpload", () => ({ prepareTurnAttachments: harness.prepareTurnAttachments, })); -vi.mock("./entities", () => ({ - useProjects: () => [], - useServerConfigs: () => new Map(), - useThreadShells: () => [], -})); +vi.mock("./projects", () => ({ environmentProjects: {} })); + +vi.mock("./workspace", () => ({ workspaceConnections: {} })); vi.mock("./server", async () => { const { Atom } = await import("effect/reactivity"); @@ -91,34 +92,30 @@ vi.mock("./git", () => ({ gitEnvironment: {} })); vi.mock("./threads", async () => { const { Atom } = await import("effect/reactivity"); + harness.threadProjection = Atom.make<{ + readonly projection: { readonly messages: ReadonlyArray<{ readonly id: string }> }; + } | null>(null).pipe(Atom.keepAlive); return { threadEnvironment: {}, - environmentThreadDetails: { threadAtom: Atom.family((_key: unknown) => Atom.make(null)) }, + environmentThreadDetails: { threadAtom: () => harness.threadProjection }, }; }); -vi.mock("./use-atom-command", () => ({ - useAtomCommand: () => async () => undefined, -})); - vi.mock("./session", () => ({ + environmentSession: {}, readEnvironmentScope: () => harness.canOperate, - useEnvironmentsWithScope: () => new Set(), + sessionHasScope: () => harness.canOperate, })); vi.mock("./use-thread-outbox", async () => { const { Atom } = await import("effect/reactivity"); return { editingQueuedMessageIdsAtom: Atom.make>({}).pipe(Atom.keepAlive), - useThreadOutboxMessages: () => ({}), - useThreadOutboxShellStatuses: () => new Map(), + dispatchingQueuedMessageIdAtom: Atom.make(null).pipe(Atom.keepAlive), + threadOutboxShellStatusesAtom: Atom.make(new Map()), }; }); -vi.mock("./use-remote-environment-registry", () => ({ - useRemoteConnectionStatus: () => ({ connectedEnvironments: [] }), -})); - vi.mock("./thread-outbox", async () => { const { createThreadOutboxManager } = await import("./thread-outbox-manager"); const { appAtomRegistry } = await import("./atom-registry"); @@ -154,7 +151,7 @@ import { recoverEditedCreationAfterDelivery, removeAcknowledgedExistingThreadMessage, restoreRejectedQueuedMessage, -} from "./use-thread-outbox-drain"; +} from "./threadOutboxDelivery"; function queuedMessage(input: { readonly messageId: string; @@ -207,6 +204,7 @@ function remainingMessages(): ReadonlyArray { beforeEach(() => { appAtomRegistry.set(acknowledgedThreadMessagesAtom, []); + appAtomRegistry.set(harness.threadProjection, null); harness.canOperate = true; harness.draftFile.setDocument({ schemaVersion: 1, drafts: {} }); }); @@ -332,6 +330,28 @@ describe("thread outbox attachment preparation", () => { }); describe("thread outbox drain delivery cleanup", () => { + it("drops echoed acknowledged rows at the next delivery without subscribing to the thread", async () => { + const first = queuedMessage({ messageId: "awaiting-echo", text: "Delivered" }); + const second = queuedMessage({ messageId: "next-delivery", text: "Also delivered" }); + await harness.manager.enqueue(first); + await harness.manager.enqueue(second); + + await expect( + completeQueuedMessageDelivery(first, harness.manager.revisionOf(first.messageId)), + ).resolves.toBe("removed"); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([first]); + + appAtomRegistry.set(harness.threadProjection, { + projection: { messages: [{ id: "unrelated" }, { id: first.messageId }] }, + }); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([first]); + + await expect( + completeQueuedMessageDelivery(second, harness.manager.revisionOf(second.messageId)), + ).resolves.toBe("removed"); + expect(appAtomRegistry.get(acknowledgedThreadMessagesAtom)).toEqual([second]); + }); + it("removes an acknowledged outbox item even when the sign-out archive write fails", async () => { const message = queuedMessage({ messageId: "archive-write-failure", text: "Delivered" }); await harness.manager.enqueue(message); diff --git a/apps/mobile/src/state/use-thread-outbox-drain.ts b/apps/mobile/src/state/threadOutboxDelivery.ts similarity index 55% rename from apps/mobile/src/state/use-thread-outbox-drain.ts rename to apps/mobile/src/state/threadOutboxDelivery.ts index 49a94b394c7bf..89c6f13358952 100644 --- a/apps/mobile/src/state/use-thread-outbox-drain.ts +++ b/apps/mobile/src/state/threadOutboxDelivery.ts @@ -1,12 +1,15 @@ import { sourceControlClients } from "@t3tools/client-runtime/source-control-clients"; import * as Dialog from "../components/ui/Dialog"; -import { useAtomValue } from "@effect/atom-react"; import { threadRuntimeIsActive, type EnvironmentProject, type EnvironmentThreadShell, } from "@t3tools/client-runtime/state/shell"; -import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime"; +import { + type AtomCommand, + type AtomCommandResult, + runAtomCommand, +} from "@t3tools/client-runtime/state/runtime"; import { threadFamilyRead, type ThreadFamilyRead } from "@t3tools/client-runtime/state/threads"; import { deriveThreadTitleSeed } from "@t3tools/client-runtime/operations"; import { @@ -15,12 +18,12 @@ import { DEFAULT_PROVIDER_INTERACTION_MODE, DEFAULT_RUNTIME_MODE, PROVIDER_SEND_TURN_MAX_ATTACHMENTS, + type EnvironmentId, type MessageId, } from "@t3tools/contracts"; import { buildTemporaryWorktreeBranchName } from "@t3tools/shared/git"; import * as Cause from "effect/Cause"; -import { AsyncResult } from "effect/reactivity"; -import { useCallback, useEffect, useRef, useState } from "react"; +import { AsyncResult, Atom } from "effect/reactivity"; import { createDebugLogger } from "../lib/debugLog"; import { scopedThreadKey } from "../lib/scopedEntities"; @@ -38,15 +41,15 @@ import { } from "./acknowledged-thread-messages"; import { appAtomRegistry } from "./atom-registry"; import { restoredNewTaskDraftKey } from "./new-task-draft-key"; -import { useProjects, useServerConfigs, useThreadShells } from "./entities"; import { clearPendingThreadCreationOutcome, pendingThreadCreationOutcomesAtom, recordPendingThreadCreationOutcome, } from "./pending-thread-creation"; -import { serverEnvironment } from "./server"; +import { environmentProjects } from "./projects"; +import { environmentServerConfigsAtom, serverEnvironment } from "./server"; import { gitEnvironment } from "./git"; -import { readEnvironmentScope, useEnvironmentsWithScope } from "./session"; +import { environmentSession, readEnvironmentScope, sessionHasScope } from "./session"; import { confirmThreadOutboxMessageQueued, threadOutboxManager, @@ -81,15 +84,13 @@ import { updateComposerDraftSettings, waitForComposerDraftsLoaded, } from "./use-composer-drafts"; -import { useAtomCommand } from "./use-atom-command"; import { dispatchingQueuedMessageIdAtom, editingQueuedMessageIdsAtom, - useThreadOutboxMessages, - useThreadOutboxShellStatuses, + threadOutboxShellStatusesAtom, } from "./use-thread-outbox"; import { clearThreadComposerError, setThreadComposerError } from "./thread-composer-error"; -import { useRemoteConnectionStatus } from "./use-remote-environment-registry"; +import { workspaceConnections } from "./workspace"; const threadOutboxDebug = createDebugLogger("thread-outbox"); @@ -571,459 +572,308 @@ async function preserveUploadedAttachmentsForEditor( } } -export function useThreadOutboxDrain(): void { - const startTurn = useAtomCommand(threadEnvironment.startTurn, { reportFailure: false }); - const preparePullRequest = useAtomCommand(gitEnvironment.preparePullRequestThread, { - reportFailure: false, - }); - const setThreadRuntimeMode = useAtomCommand(threadEnvironment.setRuntimeMode, { - reportFailure: false, - }); - const setThreadInteractionMode = useAtomCommand(threadEnvironment.setInteractionMode, { - reportFailure: false, - }); - const dispatchingQueuedMessageId = useAtomValue(dispatchingQueuedMessageIdAtom); - const editingQueuedMessageIds = useAtomValue(editingQueuedMessageIdsAtom); - const queuedMessagesByThreadKey = useThreadOutboxMessages(); - const shellStatuses = useThreadOutboxShellStatuses(); - const threads = useThreadShells(); - const creationOutcomes = useAtomValue(pendingThreadCreationOutcomesAtom); - const projects = useProjects(); - const serverConfigs = useServerConfigs(); - const { connectedEnvironments } = useRemoteConnectionStatus(); - const operableEnvironments = useEnvironmentsWithScope( +// Everything a drain pass decides from. Each queued environment's session is +// read here so a granted or revoked operate scope re-runs the drain. +const deliveryInputsAtom = Atom.make((get) => { + const connectedEnvironments = get(workspaceConnections.environmentsAtom); + const operableEnvironments = new Set(); + for (const { environmentId } of connectedEnvironments) { + if ( + sessionHasScope( + get(environmentSession.sessionStateAtom(environmentId)), + AuthOrchestrationOperateScope, + ) + ) { + operableEnvironments.add(environmentId); + } + } + return { + dispatchingQueuedMessageId: get(dispatchingQueuedMessageIdAtom), + editingQueuedMessageIds: get(editingQueuedMessageIdsAtom), + queuedMessagesByThreadKey: get(threadOutboxManager.queuedMessagesByThreadKeyAtom), + shellStatuses: get(threadOutboxShellStatusesAtom), + threads: get(environmentThreadShells.threadShellsAtom), + projects: get(environmentProjects.projectsAtom), + serverConfigs: get(environmentServerConfigsAtom), connectedEnvironments, - AuthOrchestrationOperateScope, - ); - const [retryTick, setRetryTick] = useState(0); - const retryAttemptRef = useRef(new Map()); - const retryNotBeforeRef = useRef(new Map()); - const retryTimersRef = useRef(new Map>()); - const acknowledgedExistingThreadMessageIdsRef = useRef(new Set()); - // Targets the shell may have left out hold their thread family until they leave the queue, so - // the row stays readable through dispatch. - const familyMountsRef = useRef(new Map void>()); - useEffect( - () => () => { - for (const release of familyMountsRef.current.values()) release(); - familyMountsRef.current.clear(); - }, - [], - ); - const blockedRecoverySubscriptionsRef = useRef( - new Map< - MessageId, - { readonly message: QueuedThreadMessage; readonly unsubscribe: () => void } - >(), - ); + operableEnvironments, + }; +}).pipe(Atom.withLabel("mobile:thread-outbox:delivery-inputs")); - const scheduleQueuedMessageRetry = useCallback((messageId: MessageId) => { - const retryAttempt = (retryAttemptRef.current.get(messageId) ?? 0) + 1; - retryAttemptRef.current.set(messageId, retryAttempt); - const retryDelayMs = threadOutboxRetryDelayMs(retryAttempt); - retryNotBeforeRef.current.set(messageId, Date.now() + retryDelayMs); - const pendingTimer = retryTimersRef.current.get(messageId); - if (pendingTimer !== undefined) { - clearTimeout(pendingTimer); - } - const retryTimer = setTimeout(() => { - retryTimersRef.current.delete(messageId); - setRetryTick((current) => current + 1); - }, retryDelayMs); - retryTimersRef.current.set(messageId, retryTimer); - }, []); +// Read through the shell atom, not once: the shell often lands before the +// outcome is recorded, and that entry must still be collected when it does. +const settledCreationOutcomeKeysAtom = Atom.make((get): ReadonlyArray => { + const outcomes = get(pendingThreadCreationOutcomesAtom); + const threads = get(environmentThreadShells.threadShellsAtom); + return Object.entries(outcomes).flatMap(([threadKey, outcome]) => + outcome.kind === "delivered" && + threads.some( + (thread) => + scopedThreadKey(thread.environmentId, thread.id) === threadKey && + (thread.latestRun !== null || + thread.runtime?.status === "failed" || + thread.runtime?.status === "cancelled" || + thread.runtime?.status === "interrupted"), + ) + ? [threadKey] + : [], + ); +}).pipe(Atom.withLabel("mobile:thread-outbox:settled-creation-outcomes")); - const restoreQueuedMessage = useCallback( - async (queuedMessage: QueuedThreadMessage, message: string): Promise => { - const result = await restoreRejectedQueuedMessage(queuedMessage, message); - if (result !== "blocked") { - return result !== "retry"; - } +const runDeliveryCommand = ( + command: AtomCommand, + input: W, +): Promise> => + runAtomCommand(appAtomRegistry, command, input, { reportFailure: false }); - if (!blockedRecoverySubscriptionsRef.current.has(queuedMessage.messageId)) { - const draftKey = recoveryDraftKey(queuedMessage); - const editorDraftKey = queuedMessage.creation - ? `pending-task:${queuedMessage.messageId}` - : null; - const currentDrafts = appAtomRegistry.get(composerDraftsAtom); - const blockedAttachments = currentDrafts[draftKey]?.attachments; - const editorAttachments = - editorDraftKey === null ? undefined : currentDrafts[editorDraftKey]?.attachments; - const unsubscribe = appAtomRegistry.subscribe(composerDraftsAtom, (drafts) => { - if ( - drafts[draftKey]?.attachments === blockedAttachments && - (editorDraftKey === null || drafts[editorDraftKey]?.attachments === editorAttachments) - ) { - return; - } - const active = blockedRecoverySubscriptionsRef.current.get(queuedMessage.messageId); - if (!active) { - return; - } - blockedRecoverySubscriptionsRef.current.delete(queuedMessage.messageId); - active.unsubscribe(); - setRetryTick((current) => current + 1); - }); - blockedRecoverySubscriptionsRef.current.set(queuedMessage.messageId, { - message: queuedMessage, - unsubscribe, - }); - } - return true; +function reportCommandFailure( + queuedMessage: QueuedThreadMessage, + commandResult: AtomCommandResult, + stage: ThreadOutboxCommandStage, +): { readonly action: "retry" | "restore"; readonly message: string } | null { + if (!AsyncResult.isFailure(commandResult)) { + return null; + } + const error = Cause.squash(commandResult.cause); + const action = logThreadOutboxDeliveryFailure({ + stage, + error, + interrupted: Cause.hasInterruptsOnly(commandResult.cause), + context: { + environmentId: queuedMessage.environmentId, + threadId: queuedMessage.threadId, + messageId: queuedMessage.messageId, + cause: commandResult.cause, }, - [], - ); + }); + return { + action, + message: error instanceof Error ? error.message : "The message could not be sent.", + }; +} - useEffect(() => { - let mounted = true; - const load = async () => { - if ((await threadOutboxManager.load()) || !mounted) return; - Dialog.alert( - "Some queued messages could not be loaded", - "Unreadable records and attachment files are still saved. Other messages can still be sent.", - [ - { text: "Dismiss", style: "cancel" }, - { text: "Retry", onPress: () => void load() }, - ], - ); - }; - void load(); - return () => { - mounted = false; - for (const timer of retryTimersRef.current.values()) { - clearTimeout(timer); - } - retryTimersRef.current.clear(); - for (const blocked of blockedRecoverySubscriptionsRef.current.values()) { - blocked.unsubscribe(); - } - blockedRecoverySubscriptionsRef.current.clear(); - }; - }, []); +interface ThreadOutboxRetry { + readonly attempt: number; + readonly notBefore: number; + readonly timer: ReturnType; +} - const makeDeliveryHelpers = useCallback((queuedMessage: QueuedThreadMessage) => { - const reportFailure = ( - commandResult: AtomCommandResult, - stage: ThreadOutboxCommandStage, - ): { readonly action: "retry" | "restore"; readonly message: string } | null => { - if (!AsyncResult.isFailure(commandResult)) { - return null; - } - const error = Cause.squash(commandResult.cause); - const action = logThreadOutboxDeliveryFailure({ - stage, - error, - interrupted: Cause.hasInterruptsOnly(commandResult.cause), - context: { - environmentId: queuedMessage.environmentId, - threadId: queuedMessage.threadId, - messageId: queuedMessage.messageId, - cause: commandResult.cause, - }, - }); - return { - action, - message: error instanceof Error ? error.message : "The message could not be sent.", - }; - }; - return { reportFailure }; - }, []); +/** + * Delivers queued thread messages one at a time. A drain pass runs whenever its inputs + * change (outbox, locks, shells, projects, configs, connections, scopes) and when a retry + * backoff expires. `dispatchingQueuedMessageIdAtom` is the single in-flight slot; clearing + * it re-runs the drain for the next message. + */ +export function createThreadOutboxDelivery(): { + readonly drain: () => void; + readonly dispose: () => void; +} { + let disposed = false; + const retries = new Map(); + // Existing-thread turns the server accepted but whose outbox removal has + // not landed; the next pass retries only the removal, never the send. + const acknowledgedExistingThreadMessageIds = new Set(); + // Targets the shell may have left out hold their thread family until they leave the queue, so + // the row stays readable through dispatch. + const familyMounts = new Map void>(); + const blockedRecoveries = new Map< + MessageId, + { readonly message: QueuedThreadMessage; readonly unsubscribe: () => void } + >(); - const sendQueuedMessage = useCallback( - async (queuedMessage: QueuedThreadMessage, thread: EnvironmentThreadShell) => { - const hasAccess = () => - readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); - if (!hasAccess()) return true; - const serverConfig = appAtomRegistry.get( - serverEnvironment.configValueAtom(queuedMessage.environmentId), - ); - if (!serverConfig) return false; - const settings = resolveQueuedThreadSettings(queuedMessage, thread, serverConfig.providers); - if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, thread.projectId)) { - const { title, detail } = describeUnavailableModelSelection( - serverConfig, - settings.modelSelection, - thread.projectId, - ); - return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); - } - const { reportFailure } = makeDeliveryHelpers(queuedMessage); + const retryNotBefore = (messageId: MessageId): number => retries.get(messageId)?.notBefore ?? 0; - if (settings.runtimeMode !== thread.runtimeMode) { - if (!hasAccess()) return true; - const runtimeResult = await setThreadRuntimeMode({ - environmentId: queuedMessage.environmentId, - input: { - commandId: settingsCommandId(queuedMessage, "runtime-mode"), - threadId: queuedMessage.threadId, - runtimeMode: settings.runtimeMode, - createdAt: queuedMessage.createdAt, - }, - }); - if (AsyncResult.isFailure(runtimeResult)) { - reportFailure(runtimeResult, "settings-sync"); - return false; - } - } + const scheduleRetry = (messageId: MessageId): void => { + if (disposed) return; + const previous = retries.get(messageId); + if (previous !== undefined) clearTimeout(previous.timer); + const attempt = (previous?.attempt ?? 0) + 1; + const delayMs = threadOutboxRetryDelayMs(attempt); + retries.set(messageId, { + attempt, + notBefore: Date.now() + delayMs, + timer: setTimeout(drain, delayMs), + }); + }; - if (settings.interactionMode !== thread.interactionMode) { - if (!hasAccess()) return true; - const interactionResult = await setThreadInteractionMode({ - environmentId: queuedMessage.environmentId, - input: { - commandId: settingsCommandId(queuedMessage, "interaction-mode"), - threadId: queuedMessage.threadId, - interactionMode: settings.interactionMode, - createdAt: queuedMessage.createdAt, - }, - }); - if (AsyncResult.isFailure(interactionResult)) { - reportFailure(interactionResult, "settings-sync"); - return false; - } - } + const clearRetry = (messageId: MessageId): void => { + const retry = retries.get(messageId); + if (retry === undefined) return; + clearTimeout(retry.timer); + retries.delete(messageId); + }; - let prepared: PreparedTurnAttachments; - let persistedMessage: QueuedThreadMessage; - let deliveryRevision: number; - if (!hasAccess()) return true; - try { - const preparedResult = await prepareQueuedMessageAttachments( - queuedMessage, - serverConfig.environment.capabilities.attachmentUploads === true, - ); - if (preparedResult.status === "abandoned") { - return true; - } - prepared = preparedResult.prepared; - persistedMessage = preparedResult.persistedMessage; - deliveryRevision = preparedResult.deliveryRevision; - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - await preserveUploadedAttachmentsForEditor( - queuedMessage, - preparedResult.persistedMessage, - ); - return true; - } - } catch (error) { - if (!hasAccess()) return true; - logThreadOutboxUploadFailure(queuedMessage, error); - if (!shouldRetryThreadOutboxDelivery(error)) { - return restoreQueuedMessage( - queuedMessage, - error instanceof Error ? error.message : "An attachment could not upload.", - ); - } - return false; - } - if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { - return true; + // A delivery that throws backs off like any failure. Releasing the slot + // without a retry would re-run the drain straight into the same message. + const settle = (messageId: MessageId, delivery: Promise): void => { + void delivery + .then( + (sent) => (sent ? clearRetry(messageId) : scheduleRetry(messageId)), + (error: unknown) => { + console.warn("[thread-outbox] queued message delivery threw", { messageId, error }); + scheduleRetry(messageId); + }, + ) + .finally(() => finishDispatchingQueuedMessage(messageId)); + }; + + // An over-cap draft blocks recovery until the user changes its attachments; + // parking on the draft avoids hammering the restore with backoff retries. + const restoreQueuedMessage = async ( + queuedMessage: QueuedThreadMessage, + message: string, + ): Promise => { + const result = await restoreRejectedQueuedMessage(queuedMessage, message); + if (result !== "blocked") { + return result !== "retry"; + } + if (disposed || blockedRecoveries.has(queuedMessage.messageId)) { + return true; + } + const draftKey = recoveryDraftKey(queuedMessage); + const editorDraftKey = queuedMessage.creation + ? `pending-task:${queuedMessage.messageId}` + : null; + const currentDrafts = appAtomRegistry.get(composerDraftsAtom); + const blockedAttachments = currentDrafts[draftKey]?.attachments; + const editorAttachments = + editorDraftKey === null ? undefined : currentDrafts[editorDraftKey]?.attachments; + const unsubscribe = appAtomRegistry.subscribe(composerDraftsAtom, (drafts) => { + if ( + drafts[draftKey]?.attachments === blockedAttachments && + (editorDraftKey === null || drafts[editorDraftKey]?.attachments === editorAttachments) + ) { + return; } - const currentConfig = appAtomRegistry.get( - serverEnvironment.configValueAtom(queuedMessage.environmentId), - ); - if (!currentConfig) return false; - if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, thread.projectId)) { - const { title, detail } = describeUnavailableModelSelection( - currentConfig, - settings.modelSelection, - thread.projectId, - ); - return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + const active = blockedRecoveries.get(queuedMessage.messageId); + if (!active) { + return; } - const sendSettings = resolveQueuedThreadSettings( - queuedMessage, - settings, - currentConfig.providers, + blockedRecoveries.delete(queuedMessage.messageId); + active.unsubscribe(); + drain(); + }); + blockedRecoveries.set(queuedMessage.messageId, { message: queuedMessage, unsubscribe }); + return true; + }; + + const sendQueuedMessage = async ( + queuedMessage: QueuedThreadMessage, + thread: EnvironmentThreadShell, + ): Promise => { + const hasAccess = () => + readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); + if (!hasAccess()) return true; + const serverConfig = appAtomRegistry.get( + serverEnvironment.configValueAtom(queuedMessage.environmentId), + ); + if (!serverConfig) return false; + const settings = resolveQueuedThreadSettings(queuedMessage, thread, serverConfig.providers); + if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, thread.projectId)) { + const { title, detail } = describeUnavailableModelSelection( + serverConfig, + settings.modelSelection, + thread.projectId, ); + return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); + } + + if (settings.runtimeMode !== thread.runtimeMode) { if (!hasAccess()) return true; - const deliveryResult = await startTurn({ + const runtimeResult = await runDeliveryCommand(threadEnvironment.setRuntimeMode, { environmentId: queuedMessage.environmentId, input: { - commandId: queuedMessage.commandId, - creationSource: "mobile", + commandId: settingsCommandId(queuedMessage, "runtime-mode"), threadId: queuedMessage.threadId, - message: { - messageId: queuedMessage.messageId, - role: "user", - ...serializeComposerMessageForServer( - queuedMessage.text, - uploadedComposerContext( - queuedMessage.context, - queuedMessage.attachments, - prepared.attachments, - ), - currentConfig.environment.capabilities.inlineMessageContext === true, - ), - attachments: prepared.attachments, - }, - modelSelection: sendSettings.modelSelection, - titleSeed: deriveThreadTitleSeed({ - text: queuedMessage.text, - attachments: queuedMessage.attachments, - }), - runtimeMode: sendSettings.runtimeMode, - interactionMode: sendSettings.interactionMode, + runtimeMode: settings.runtimeMode, createdAt: queuedMessage.createdAt, - dispatchMode: queuedMessage.dispatchMode ?? "start", }, }); - if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; - const failure = reportFailure(deliveryResult, "start-turn"); - if (failure?.action === "retry") { + if (AsyncResult.isFailure(runtimeResult)) { + reportCommandFailure(queuedMessage, runtimeResult, "settings-sync"); return false; } - if (failure?.action === "restore") { - return restoreQueuedMessage(persistedMessage, failure.message); - } - acknowledgedExistingThreadMessageIdsRef.current.add(persistedMessage.messageId); - const delivered = - (await completeQueuedMessageDelivery(persistedMessage, deliveryRevision)) === "removed"; - if (delivered) { - acknowledgedExistingThreadMessageIdsRef.current.delete(persistedMessage.messageId); - } - return delivered; - }, - [ - makeDeliveryHelpers, - setThreadInteractionMode, - setThreadRuntimeMode, - startTurn, - restoreQueuedMessage, - ], - ); + } - const sendQueuedCreation = useCallback( - async ( - queuedMessage: QueuedThreadMessage, - creation: QueuedThreadCreation, - projectCwd: string, - ) => { - const hasAccess = () => - readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); + if (settings.interactionMode !== thread.interactionMode) { if (!hasAccess()) return true; - const modelSelection = queuedMessage.modelSelection; - if (modelSelection === undefined) { + const interactionResult = await runDeliveryCommand(threadEnvironment.setInteractionMode, { + environmentId: queuedMessage.environmentId, + input: { + commandId: settingsCommandId(queuedMessage, "interaction-mode"), + threadId: queuedMessage.threadId, + interactionMode: settings.interactionMode, + createdAt: queuedMessage.createdAt, + }, + }); + if (AsyncResult.isFailure(interactionResult)) { + reportCommandFailure(queuedMessage, interactionResult, "settings-sync"); return false; } - const serverConfig = appAtomRegistry.get( - serverEnvironment.configValueAtom(queuedMessage.environmentId), - ); - if (!serverConfig) return false; - const settings = resolveQueuedThreadSettings( + } + + let prepared: PreparedTurnAttachments; + let persistedMessage: QueuedThreadMessage; + let deliveryRevision: number; + if (!hasAccess()) return true; + try { + const preparedResult = await prepareQueuedMessageAttachments( queuedMessage, - { - modelSelection, - runtimeMode: DEFAULT_RUNTIME_MODE, - interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, - }, - serverConfig.providers, + serverConfig.environment.capabilities.attachmentUploads === true, ); - if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, creation.projectId)) { - const { title, detail } = describeUnavailableModelSelection( - serverConfig, - settings.modelSelection, - creation.projectId, - ); - return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); - } - let prepared: PreparedTurnAttachments; - let persistedMessage: QueuedThreadMessage; - let deliveryRevision: number; - try { - const preparedResult = await prepareQueuedMessageAttachments( - queuedMessage, - serverConfig.environment.capabilities.attachmentUploads === true, - ); - if (preparedResult.status === "abandoned") { - return true; - } - prepared = preparedResult.prepared; - persistedMessage = preparedResult.persistedMessage; - deliveryRevision = preparedResult.deliveryRevision; - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - await preserveUploadedAttachmentsForEditor( - queuedMessage, - preparedResult.persistedMessage, - ); - return true; - } - } catch (error) { - if (!hasAccess()) return true; - logThreadOutboxUploadFailure(queuedMessage, error); - if (!shouldRetryThreadOutboxDelivery(error)) { - return restoreQueuedMessage( - queuedMessage, - error instanceof Error ? error.message : "An attachment could not upload.", - ); - } - return false; + if (preparedResult.status === "abandoned") { + return true; } - if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { + prepared = preparedResult.prepared; + persistedMessage = preparedResult.persistedMessage; + deliveryRevision = preparedResult.deliveryRevision; + if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { + await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage); return true; } - const currentConfig = appAtomRegistry.get( - serverEnvironment.configValueAtom(queuedMessage.environmentId), - ); - if (!currentConfig) return false; - if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, creation.projectId)) { - const { title, detail } = describeUnavailableModelSelection( - currentConfig, - settings.modelSelection, - creation.projectId, + } catch (error) { + if (!hasAccess()) return true; + logThreadOutboxUploadFailure(queuedMessage, error); + if (!shouldRetryThreadOutboxDelivery(error)) { + return restoreQueuedMessage( + queuedMessage, + error instanceof Error ? error.message : "An attachment could not upload.", ); - return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); } - const sendSettings = resolveQueuedThreadSettings( - queuedMessage, - settings, - currentConfig.providers, + return false; + } + if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { + return true; + } + const currentConfig = appAtomRegistry.get( + serverEnvironment.configValueAtom(queuedMessage.environmentId), + ); + if (!currentConfig) return false; + if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, thread.projectId)) { + const { title, detail } = describeUnavailableModelSelection( + currentConfig, + settings.modelSelection, + thread.projectId, ); - if (!hasAccess()) return true; - const { reportFailure } = makeDeliveryHelpers(queuedMessage); - let workspace = creation; - if (creation.pullRequestReference) { - const checkout = await preparePullRequest({ - environmentId: queuedMessage.environmentId, - input: { cwd: projectCwd, reference: creation.pullRequestReference, mode: "worktree" }, - }); - if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) || !hasAccess()) - return true; - const failure = reportFailure(checkout, "start-turn"); - if (failure?.action === "retry") return false; - if (failure?.action === "restore") - return restoreQueuedMessage(persistedMessage, failure.message); - if (!AsyncResult.isSuccess(checkout)) return false; - if (!checkout.value.worktreePath || !checkout.value.isOnPullRequestHead) { - const { shortLabel } = ( - sourceControlClients.findByChangeRequestUrl(creation.pullRequestReference) ?? - sourceControlClients.get(undefined) - ).changeRequest; - return restoreQueuedMessage( - persistedMessage, - `The ${shortLabel} worktree has local changes and could not update to the ${shortLabel} head. Resolve them before trying again.`, - ); - } - workspace = { - ...creation, - workspaceMode: "local", - branch: checkout.value.branch, - worktreePath: checkout.value.worktreePath, - startFromOrigin: false, - }; - } - const deliveryResult = await startTurn({ - environmentId: queuedMessage.environmentId, - input: buildProjectThreadStartTurnInput({ - projectId: creation.projectId, - projectCwd, - threadId: queuedMessage.threadId, - commandId: queuedMessage.commandId, + return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + } + const sendSettings = resolveQueuedThreadSettings( + queuedMessage, + settings, + currentConfig.providers, + ); + if (!hasAccess()) return true; + const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, { + environmentId: queuedMessage.environmentId, + input: { + commandId: queuedMessage.commandId, + creationSource: "mobile", + threadId: queuedMessage.threadId, + message: { messageId: queuedMessage.messageId, - createdAt: queuedMessage.createdAt, - titleText: queuedMessage.text, + role: "user", ...serializeComposerMessageForServer( - queuedMessage.text.trim(), + queuedMessage.text, uploadedComposerContext( queuedMessage.context, queuedMessage.attachments, @@ -1031,58 +881,235 @@ export function useThreadOutboxDrain(): void { ), currentConfig.environment.capabilities.inlineMessageContext === true, ), - uploadedAttachments: prepared.attachments, - modelSelection: sendSettings.modelSelection, - runtimeMode: sendSettings.runtimeMode, - interactionMode: sendSettings.interactionMode, - workspaceMode: workspace.workspaceMode, - branch: workspace.branch, - worktreePath: workspace.worktreePath, - startFromOrigin: workspace.startFromOrigin ?? false, - worktreeBranchName: buildTemporaryWorktreeBranchName(randomHex), + attachments: prepared.attachments, + }, + modelSelection: sendSettings.modelSelection, + titleSeed: deriveThreadTitleSeed({ + text: queuedMessage.text, + attachments: queuedMessage.attachments, }), - }); - if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; - const failure = reportFailure(deliveryResult, "start-turn"); - if (failure?.action === "retry") { - return false; + runtimeMode: sendSettings.runtimeMode, + interactionMode: sendSettings.interactionMode, + createdAt: queuedMessage.createdAt, + dispatchMode: queuedMessage.dispatchMode ?? "start", + }, + }); + if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; + const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn"); + if (failure?.action === "retry") { + return false; + } + if (failure?.action === "restore") { + return restoreQueuedMessage(persistedMessage, failure.message); + } + acknowledgedExistingThreadMessageIds.add(persistedMessage.messageId); + const delivered = + (await completeQueuedMessageDelivery(persistedMessage, deliveryRevision)) === "removed"; + if (delivered) { + acknowledgedExistingThreadMessageIds.delete(persistedMessage.messageId); + } + return delivered; + }; + + const sendQueuedCreation = async ( + queuedMessage: QueuedThreadMessage, + creation: QueuedThreadCreation, + projectCwd: string, + ): Promise => { + const hasAccess = () => + readEnvironmentScope(queuedMessage.environmentId, AuthOrchestrationOperateScope); + if (!hasAccess()) return true; + const modelSelection = queuedMessage.modelSelection; + if (modelSelection === undefined) { + return false; + } + const serverConfig = appAtomRegistry.get( + serverEnvironment.configValueAtom(queuedMessage.environmentId), + ); + if (!serverConfig) return false; + const settings = resolveQueuedThreadSettings( + queuedMessage, + { + modelSelection, + runtimeMode: DEFAULT_RUNTIME_MODE, + interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE, + }, + serverConfig.providers, + ); + if (isModelSelectionUnavailable(serverConfig, settings.modelSelection, creation.projectId)) { + const { title, detail } = describeUnavailableModelSelection( + serverConfig, + settings.modelSelection, + creation.projectId, + ); + return restoreQueuedMessage(queuedMessage, `${title}. ${detail}`); + } + let prepared: PreparedTurnAttachments; + let persistedMessage: QueuedThreadMessage; + let deliveryRevision: number; + try { + const preparedResult = await prepareQueuedMessageAttachments( + queuedMessage, + serverConfig.environment.capabilities.attachmentUploads === true, + ); + if (preparedResult.status === "abandoned") { + return true; } - if (failure?.action === "restore") { + prepared = preparedResult.prepared; + persistedMessage = preparedResult.persistedMessage; + deliveryRevision = preparedResult.deliveryRevision; + if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { + await preserveUploadedAttachmentsForEditor(queuedMessage, preparedResult.persistedMessage); + return true; + } + } catch (error) { + if (!hasAccess()) return true; + logThreadOutboxUploadFailure(queuedMessage, error); + if (!shouldRetryThreadOutboxDelivery(error)) { + return restoreQueuedMessage( + queuedMessage, + error instanceof Error ? error.message : "An attachment could not upload.", + ); + } + return false; + } + if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision)) { + return true; + } + const currentConfig = appAtomRegistry.get( + serverEnvironment.configValueAtom(queuedMessage.environmentId), + ); + if (!currentConfig) return false; + if (isModelSelectionUnavailable(currentConfig, settings.modelSelection, creation.projectId)) { + const { title, detail } = describeUnavailableModelSelection( + currentConfig, + settings.modelSelection, + creation.projectId, + ); + return restoreQueuedMessage(persistedMessage, `${title}. ${detail}`); + } + const sendSettings = resolveQueuedThreadSettings( + queuedMessage, + settings, + currentConfig.providers, + ); + if (!hasAccess()) return true; + let workspace = creation; + if (creation.pullRequestReference) { + const checkout = await runDeliveryCommand(gitEnvironment.preparePullRequestThread, { + environmentId: queuedMessage.environmentId, + input: { cwd: projectCwd, reference: creation.pullRequestReference, mode: "worktree" }, + }); + if (!isQueuedMessagePayloadCurrent(persistedMessage, deliveryRevision) || !hasAccess()) + return true; + const failure = reportCommandFailure(queuedMessage, checkout, "start-turn"); + if (failure?.action === "retry") return false; + if (failure?.action === "restore") return restoreQueuedMessage(persistedMessage, failure.message); + if (!AsyncResult.isSuccess(checkout)) return false; + if (!checkout.value.worktreePath || !checkout.value.isOnPullRequestHead) { + const { shortLabel } = ( + sourceControlClients.findByChangeRequestUrl(creation.pullRequestReference) ?? + sourceControlClients.get(undefined) + ).changeRequest; + return restoreQueuedMessage( + persistedMessage, + `The ${shortLabel} worktree has local changes and could not update to the ${shortLabel} head. Resolve them before trying again.`, + ); } - recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage }); - const outcome = await completeQueuedMessageDelivery(persistedMessage, deliveryRevision); - if (outcome === "edited") { - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { - return true; - } - return recoverEditedCreationAfterDelivery(persistedMessage); + workspace = { + ...creation, + workspaceMode: "local", + branch: checkout.value.branch, + worktreePath: checkout.value.worktreePath, + startFromOrigin: false, + }; + } + const deliveryResult = await runDeliveryCommand(threadEnvironment.startTurn, { + environmentId: queuedMessage.environmentId, + input: buildProjectThreadStartTurnInput({ + projectId: creation.projectId, + projectCwd, + threadId: queuedMessage.threadId, + commandId: queuedMessage.commandId, + messageId: queuedMessage.messageId, + createdAt: queuedMessage.createdAt, + titleText: queuedMessage.text, + ...serializeComposerMessageForServer( + queuedMessage.text.trim(), + uploadedComposerContext( + queuedMessage.context, + queuedMessage.attachments, + prepared.attachments, + ), + currentConfig.environment.capabilities.inlineMessageContext === true, + ), + uploadedAttachments: prepared.attachments, + modelSelection: sendSettings.modelSelection, + runtimeMode: sendSettings.runtimeMode, + interactionMode: sendSettings.interactionMode, + workspaceMode: workspace.workspaceMode, + branch: workspace.branch, + worktreePath: workspace.worktreePath, + startFromOrigin: workspace.startFromOrigin ?? false, + worktreeBranchName: buildTemporaryWorktreeBranchName(randomHex), + }), + }); + if (AsyncResult.isFailure(deliveryResult) && !hasAccess()) return true; + const failure = reportCommandFailure(queuedMessage, deliveryResult, "start-turn"); + if (failure?.action === "retry") { + return false; + } + if (failure?.action === "restore") { + return restoreQueuedMessage(persistedMessage, failure.message); + } + recordPendingThreadCreationOutcome({ kind: "delivered", message: persistedMessage }); + const outcome = await completeQueuedMessageDelivery(persistedMessage, deliveryRevision); + if (outcome === "edited") { + if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[queuedMessage.messageId]) { + return true; } - return outcome === "removed"; - }, - [makeDeliveryHelpers, preparePullRequest, restoreQueuedMessage, startTurn], - ); + return recoverEditedCreationAfterDelivery(persistedMessage); + } + return outcome === "removed"; + }; - // Subscribe to outcomes; they may arrive after the last shell update, leaving read-once entries uncollected. - useEffect(() => { - for (const [threadKey, outcome] of Object.entries(creationOutcomes)) { - if ( - outcome.kind === "delivered" && - threads.some( - (thread) => - scopedThreadKey(thread.environmentId, thread.id) === threadKey && - (thread.latestRun !== null || - thread.runtime?.status === "failed" || - thread.runtime?.status === "cancelled" || - thread.runtime?.status === "interrupted"), - ) - ) { - clearPendingThreadCreationOutcome(threadKey); - } + // A pass writes atoms the pass reads (family mounts, the dispatch slot), and the registry + // notifies subscribers synchronously, so drain() can be called from inside a pass. That call + // only asks for another pass; a nested pass would decide from inputs the outer one is still + // acting on and could start a second delivery. + let draining = false; + let drainRequested = false; + function drain(): void { + if (disposed) return; + if (draining) { + drainRequested = true; + return; + } + draining = true; + try { + do { + if (disposed) return; + drainRequested = false; + drainPass(); + } while (drainRequested); + } finally { + draining = false; } - }, [creationOutcomes, threads]); + } - useEffect(() => { + function drainPass(): void { + const { + dispatchingQueuedMessageId, + editingQueuedMessageIds, + queuedMessagesByThreadKey, + shellStatuses, + threads, + projects, + serverConfigs, + connectedEnvironments, + operableEnvironments, + } = appAtomRegistry.get(deliveryInputsAtom); if (dispatchingQueuedMessageId !== null) { return; } @@ -1092,15 +1119,15 @@ export function useThreadOutboxDrain(): void { .flat() .map((message) => message.messageId), ); - for (const messageId of acknowledgedExistingThreadMessageIdsRef.current) { + for (const messageId of acknowledgedExistingThreadMessageIds) { if (!queuedMessageIds.has(messageId)) { - acknowledgedExistingThreadMessageIdsRef.current.delete(messageId); + acknowledgedExistingThreadMessageIds.delete(messageId); } } - for (const [messageId, release] of familyMountsRef.current) { + for (const [messageId, release] of familyMounts) { if (!queuedMessageIds.has(messageId)) { release(); - familyMountsRef.current.delete(messageId); + familyMounts.delete(messageId); } } @@ -1109,48 +1136,36 @@ export function useThreadOutboxDrain(): void { if (!nextQueuedMessage) { continue; } + const messageId = nextQueuedMessage.messageId; if ( nextQueuedMessage.creation === undefined && - acknowledgedExistingThreadMessageIdsRef.current.has(nextQueuedMessage.messageId) + acknowledgedExistingThreadMessageIds.has(messageId) ) { - if ((retryNotBeforeRef.current.get(nextQueuedMessage.messageId) ?? 0) > Date.now()) { + if (retryNotBefore(messageId) > Date.now()) { continue; } - beginDispatchingQueuedMessage(nextQueuedMessage.messageId); - void removeAcknowledgedExistingThreadMessage( - nextQueuedMessage, - acknowledgedExistingThreadMessageIdsRef.current, - ) - .then((removed) => { - if (!removed) { - scheduleQueuedMessageRetry(nextQueuedMessage.messageId); - return; - } - retryAttemptRef.current.delete(nextQueuedMessage.messageId); - retryNotBeforeRef.current.delete(nextQueuedMessage.messageId); - const pendingTimer = retryTimersRef.current.get(nextQueuedMessage.messageId); - if (pendingTimer !== undefined) { - clearTimeout(pendingTimer); - retryTimersRef.current.delete(nextQueuedMessage.messageId); - } - }) - .finally(() => finishDispatchingQueuedMessage(nextQueuedMessage.messageId)); + beginDispatchingQueuedMessage(messageId); + settle( + messageId, + removeAcknowledgedExistingThreadMessage( + nextQueuedMessage, + acknowledgedExistingThreadMessageIds, + ), + ); return; } - if (editingQueuedMessageIds[nextQueuedMessage.messageId]) { + if (editingQueuedMessageIds[messageId]) { continue; } - const blockedRecovery = blockedRecoverySubscriptionsRef.current.get( - nextQueuedMessage.messageId, - ); + const blockedRecovery = blockedRecoveries.get(messageId); if (blockedRecovery) { if (blockedRecovery.message === nextQueuedMessage) { continue; } - blockedRecoverySubscriptionsRef.current.delete(nextQueuedMessage.messageId); + blockedRecoveries.delete(messageId); blockedRecovery.unsubscribe(); } - if ((retryNotBeforeRef.current.get(nextQueuedMessage.messageId) ?? 0) > Date.now()) { + if (retryNotBefore(messageId) > Date.now()) { continue; } @@ -1173,8 +1188,8 @@ export function useThreadOutboxDrain(): void { ) { // The family keeps the row readable through dispatch once it loads; the current shell // generation's read decides whether the thread is gone. - if (!familyMountsRef.current.has(nextQueuedMessage.messageId)) { - familyMountsRef.current.set( + if (!familyMounts.has(nextQueuedMessage.messageId)) { + familyMounts.set( nextQueuedMessage.messageId, threadFamilies.mount( appAtomRegistry, @@ -1189,8 +1204,8 @@ export function useThreadOutboxDrain(): void { ), ); if (familyRead === "settled") { - // The rows from this render can lag the family that just settled; decide from the - // merged rows as they are now. + // The rows read at the start of this pass can lag the family that just settled; + // decide from the merged rows as they are now. thread = findThread( appAtomRegistry.get(environmentThreadShells.threadShellsAtom), nextQueuedMessage, @@ -1218,7 +1233,7 @@ export function useThreadOutboxDrain(): void { familyRead !== "settled" ) { // An empty family read changes no merged row, so nothing else would wake the drain. - scheduleQueuedMessageRetry(nextQueuedMessage.messageId); + scheduleRetry(messageId); continue; } if (deliveryAction === "send" && !operableEnvironments.has(nextQueuedMessage.environmentId)) { @@ -1240,28 +1255,20 @@ export function useThreadOutboxDrain(): void { continue; } if (dispatchStep.step === "retry") { - scheduleQueuedMessageRetry(nextQueuedMessage.messageId); + scheduleRetry(messageId); continue; } if (dispatchStep.step === "restore") { const attachmentError = dispatchStep.reason; - beginDispatchingQueuedMessage(nextQueuedMessage.messageId); - void confirmThreadOutboxMessageQueued(nextQueuedMessage) - .then((queued) => { - if ( - !queued || - appAtomRegistry.get(editingQueuedMessageIdsAtom)[nextQueuedMessage.messageId] - ) { - return true; - } - return restoreQueuedMessage(nextQueuedMessage, attachmentError); - }) - .then((restored) => { - if (!restored) { - scheduleQueuedMessageRetry(nextQueuedMessage.messageId); - } - }) - .finally(() => finishDispatchingQueuedMessage(nextQueuedMessage.messageId)); + beginDispatchingQueuedMessage(messageId); + settle( + messageId, + confirmThreadOutboxMessageQueued(nextQueuedMessage).then((queued) => + !queued || appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId] + ? true + : restoreQueuedMessage(nextQueuedMessage, attachmentError), + ), + ); return; } const creationProjectCwd = @@ -1279,7 +1286,7 @@ export function useThreadOutboxDrain(): void { } } - beginDispatchingQueuedMessage(nextQueuedMessage.messageId); + beginDispatchingQueuedMessage(messageId); const removeQueuedMessage = (warning: string) => removeThreadOutboxMessage(nextQueuedMessage).then( () => true, @@ -1287,7 +1294,7 @@ export function useThreadOutboxDrain(): void { console.warn(warning, { environmentId: nextQueuedMessage.environmentId, threadId: nextQueuedMessage.threadId, - messageId: nextQueuedMessage.messageId, + messageId, error, }); return false; @@ -1299,7 +1306,7 @@ export function useThreadOutboxDrain(): void { return true; } // Re-check editor ownership after confirmation; return true to defer without failure backoff. - if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[nextQueuedMessage.messageId]) { + if (appAtomRegistry.get(editingQueuedMessageIdsAtom)[messageId]) { return true; } if (deliveryAction === "send") { @@ -1307,13 +1314,12 @@ export function useThreadOutboxDrain(): void { appAtomRegistry.get(environmentThreadShells.threadShellsAtom), nextQueuedMessage, ); - const liveThreadBusy = threadRuntimeIsActive(liveThread?.runtime); const liveDeliveryAction = resolveThreadOutboxDeliveryAction({ isCreation: creation !== undefined, threadExists: liveThread !== undefined, shellStatus, environmentConnected: environment?.connectionState === "connected", - threadBusy: liveThreadBusy, + threadBusy: threadRuntimeIsActive(liveThread?.runtime), }); if (liveDeliveryAction !== "send") { return true; @@ -1332,41 +1338,57 @@ export function useThreadOutboxDrain(): void { ? sendQueuedMessage(nextQueuedMessage, thread) : Promise.resolve(false); }); - void delivery - .then((sent) => { - if (sent) { - retryAttemptRef.current.delete(nextQueuedMessage.messageId); - retryNotBeforeRef.current.delete(nextQueuedMessage.messageId); - const pendingTimer = retryTimersRef.current.get(nextQueuedMessage.messageId); - if (pendingTimer !== undefined) { - clearTimeout(pendingTimer); - retryTimersRef.current.delete(nextQueuedMessage.messageId); - } - return; - } - - scheduleQueuedMessageRetry(nextQueuedMessage.messageId); - }) - .finally(() => { - finishDispatchingQueuedMessage(nextQueuedMessage.messageId); - }); + settle(messageId, delivery); return; } - }, [ - connectedEnvironments, - dispatchingQueuedMessageId, - editingQueuedMessageIds, - operableEnvironments, - projects, - queuedMessagesByThreadKey, - // oxlint-disable-next-line react/exhaustive-effect-dependencies -- retryTick re-runs the drain when a retry timer fires. - retryTick, - restoreQueuedMessage, - scheduleQueuedMessageRetry, - sendQueuedCreation, - sendQueuedMessage, - serverConfigs, - shellStatuses, - threads, - ]); + } + + const stopDraining = appAtomRegistry.subscribe(deliveryInputsAtom, drain, { immediate: true }); + const stopCollectingOutcomes = appAtomRegistry.subscribe( + settledCreationOutcomeKeysAtom, + (threadKeys) => { + for (const threadKey of threadKeys) clearPendingThreadCreationOutcome(threadKey); + }, + { immediate: true }, + ); + + return { + drain, + dispose: () => { + disposed = true; + stopDraining(); + stopCollectingOutcomes(); + for (const retry of retries.values()) clearTimeout(retry.timer); + retries.clear(); + for (const blocked of blockedRecoveries.values()) blocked.unsubscribe(); + blockedRecoveries.clear(); + for (const release of familyMounts.values()) release(); + familyMounts.clear(); + }, + }; +} + +function loadThreadOutbox(isActive: () => boolean): void { + void threadOutboxManager.load().then((loaded) => { + if (loaded || !isActive()) return; + Dialog.alert( + "Some queued messages could not be loaded", + "Unreadable records and attachment files are still saved. Other messages can still be sent.", + [ + { text: "Dismiss", style: "cancel" }, + { text: "Retry", onPress: () => loadThreadOutbox(isActive) }, + ], + ); + }); +} + +/** App-lifetime: loads the persisted outbox and delivers queued messages. */ +export function installThreadOutboxDelivery(): () => void { + let active = true; + loadThreadOutbox(() => active); + const delivery = createThreadOutboxDelivery(); + return () => { + active = false; + delivery.dispose(); + }; } diff --git a/apps/mobile/src/state/use-thread-outbox.ts b/apps/mobile/src/state/use-thread-outbox.ts index 8339472a99617..a1128cbd08b30 100644 --- a/apps/mobile/src/state/use-thread-outbox.ts +++ b/apps/mobile/src/state/use-thread-outbox.ts @@ -7,7 +7,7 @@ import { appAtomRegistry } from "./atom-registry"; import { environmentShell } from "./shell"; import { threadOutboxManager } from "./thread-outbox"; -const threadOutboxShellStatusesAtom = Atom.make( +export const threadOutboxShellStatusesAtom = Atom.make( (get): ReadonlyMap => { const statuses = new Map(); for (const queue of Object.values(get(threadOutboxManager.queuedMessagesByThreadKeyAtom))) { @@ -68,7 +68,3 @@ export const queuedThreadKeysAtom = Atom.make((get): ReadonlySet => { export function useQueuedThreadKeys(): ReadonlySet { return useAtomValue(queuedThreadKeysAtom); } - -export function useThreadOutboxShellStatuses() { - return useAtomValue(threadOutboxShellStatusesAtom); -} From 08bd2ec09c29996a5b3015f4a4cc4a93541eed42 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 26 Oct 2026 17:01:25 -0700 Subject: [PATCH 2/9] test(web): PDF viewer behavior is covered by fast tests (#25699) Co-authored-by: Claude Opus 5.5 --- .../files/PdfViewer.browser.test.tsx | 111 +++++++++++++++++ apps/web/src/components/files/PdfViewer.tsx | 73 +++++------ .../src/components/files/pdfLayout.test.ts | 113 ++++++++++++++++++ apps/web/src/components/files/pdfLayout.ts | 73 +++++++++++ 4 files changed, 325 insertions(+), 45 deletions(-) create mode 100644 apps/web/src/components/files/PdfViewer.browser.test.tsx create mode 100644 apps/web/src/components/files/pdfLayout.test.ts create mode 100644 apps/web/src/components/files/pdfLayout.ts diff --git a/apps/web/src/components/files/PdfViewer.browser.test.tsx b/apps/web/src/components/files/PdfViewer.browser.test.tsx new file mode 100644 index 0000000000000..95100d12d3640 --- /dev/null +++ b/apps/web/src/components/files/PdfViewer.browser.test.tsx @@ -0,0 +1,111 @@ +import { expect, it, vi } from "vite-plus/test"; +import { render } from "../../../test/render"; +import "~/index.css"; + +// Vite serves the worker module through its transform with an inline source map (6.8 MB for +// a 1.3 MB file), which dominated this test under CPU contention. A blob of the raw file is the +// same code without the dev-server cost. +vi.mock(import("pdfjs-dist/build/pdf.worker.min.mjs?url"), async () => { + const { default: source } = await import("pdfjs-dist/build/pdf.worker.min.mjs?raw"); + return { + default: URL.createObjectURL(new Blob([source], { type: "text/javascript" })), + }; +}); + +import PdfViewer from "./PdfViewer"; + +// Page 1 is a short banner whose title is drawn in two runs with a font change, so pdf.js +// splits it into two text spans. Page 2 is a letter page rotated a quarter turn. +function twoPagePdf() { + const pages = [ + { + box: "0 0 612 140", + rotate: 0, + text: "BT /F1 24 Tf 30 70 Td (Quarter) Tj /F2 24 Tf (ly outlook) Tj ET", + }, + { box: "0 0 612 792", rotate: 90, text: "BT /F1 24 Tf 30 700 Td (Budget and risks) Tj ET" }, + ]; + const objects = [ + "<< /Type /Catalog /Pages 2 0 R >>", + "<< /Type /Pages /Count 2 /Kids [3 0 R 5 0 R] >>", + ...pages.flatMap(({ box, rotate, text }, index) => [ + `<< /Type /Page /Parent 2 0 R /MediaBox [${box}] /Rotate ${rotate} /Resources << /Font << /F1 7 0 R /F2 8 0 R >> >> /Contents ${4 + index * 2} 0 R >>`, + `<< /Length ${text.length} >>\nstream\n${text}\nendstream`, + ]), + "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>", + "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica-Bold >>", + ]; + let source = "%PDF-1.4\n"; + const offsets: number[] = []; + for (const [index, object] of objects.entries()) { + offsets.push(source.length); + source += `${index + 1} 0 obj\n${object}\nendobj\n`; + } + const xref = source.length; + source += `xref\n0 ${objects.length + 1}\n0000000000 65535 f \n${offsets + .map((offset) => `${String(offset).padStart(10, "0")} 00000 n \n`) + .join("")}trailer\n<< /Size ${objects.length + 1} /Root 1 0 R >>\nstartxref\n${xref}\n%%EOF`; + return new Blob([source], { type: "application/pdf" }); +} + +it("fits the width, then finds split and rotated text and jumps to its page", async () => { + const url = URL.createObjectURL(twoPagePdf()); + try { + const container = document.createElement("div"); + container.style.cssText = "display:flex;width:500px;height:600px"; + await using screen = await render(, { + container, + }); + // The milestone is pdf.js booting its worker and parsing the document, not a frame count. + await expect.element(screen.getByText("1 / 2 pages"), { timeout: 10_000 }).toBeVisible(); + const region = screen.container.querySelector('[role="region"]')!; + // Fit width follows the measured viewport, which settles once the scrollbar appears. + await vi.waitFor(() => { + const canvas = region.querySelector('canvas[aria-label="Page 1"]')!; + expect(canvas.getBoundingClientRect().width).toBe(region.clientWidth - 32); + expect(region.scrollWidth).toBe(region.clientWidth); + }); + + const find = screen.getByRole("searchbox", { name: "Find in PDF" }); + await find.fill("quarterly outlook"); + await expect.element(screen.getByRole("status")).toHaveTextContent("1/1"); + await vi.waitFor(() => + expect( + Array.from(region.querySelectorAll(".pdf-find-match"), (span) => span.textContent), + ).toEqual(["Quarter", "ly outlook"]), + ); + + await find.fill("budget"); + await expect.element(screen.getByText("2 / 2 pages")).toBeVisible(); + await expect.element(screen.getByRole("status")).toHaveTextContent("1/1"); + const rotated = await vi.waitFor(() => { + const span = Array.from(region.querySelectorAll("[data-pdf-text-layer] span")).find( + (node) => node.textContent === "Budget and risks", + ); + expect(span).toBeDefined(); + return span!; + }); + // The rotated page's text runs top to bottom inside the page, so a selection lands on it. + const textBounds = rotated.getBoundingClientRect(); + const pageBounds = rotated.closest("[data-pdf-text-layer]")!.getBoundingClientRect(); + expect(textBounds.height).toBeGreaterThan(textBounds.width); + expect(textBounds.width).toBeGreaterThan(0); + expect(textBounds.left).toBeGreaterThanOrEqual(pageBounds.left - 1); + expect(textBounds.top).toBeGreaterThanOrEqual(pageBounds.top - 1); + expect(textBounds.right).toBeLessThanOrEqual(pageBounds.right + 1); + expect(textBounds.bottom).toBeLessThanOrEqual(pageBounds.bottom + 1); + expect(getComputedStyle(rotated).userSelect).toBe("text"); + const range = document.createRange(); + range.selectNodeContents(rotated); + const selection = window.getSelection()!; + selection.removeAllRanges(); + selection.addRange(range); + expect(selection.toString()).toBe("Budget and risks"); + selection.removeAllRanges(); + + await find.fill(" "); + await expect.element(screen.getByRole("status")).toHaveTextContent("0/0"); + } finally { + URL.revokeObjectURL(url); + } +}); diff --git a/apps/web/src/components/files/PdfViewer.tsx b/apps/web/src/components/files/PdfViewer.tsx index 70f005a532ed5..4a80112ddef1c 100644 --- a/apps/web/src/components/files/PdfViewer.tsx +++ b/apps/web/src/components/files/PdfViewer.tsx @@ -13,6 +13,18 @@ import { observeResize } from "~/lib/observeResize"; import { FileSurfaceAction, FileSurfaceFailure, FileSurfaceLoading } from "./fileSurfaceChrome"; import { readBoundedDocument } from "./readBoundedDocument"; import { openPdf } from "./pdfDocument"; +import { + currentPdfPage, + pdfFindMatchRuns, + pdfPageOffsets, + pdfPageScrollTop, + pdfPageText, + pdfPageWidth, + PDF_MAX_ZOOM, + PDF_MIN_ZOOM, + stepPdfZoom, + visiblePdfPages, +} from "./pdfLayout"; import "./pdfViewer.css"; const MAX_PAGES = 2000; @@ -83,25 +95,12 @@ function PdfPage(props: { const node = text.current; if (!node) return; const mark = () => { - const runs = Array.from(node.querySelectorAll('span[role="presentation"], br')).map( - (element) => ({ - element, - text: element.tagName === "BR" ? "\n" : (element.textContent ?? "").toLowerCase(), - }), + const elements = Array.from(node.querySelectorAll('span[role="presentation"], br')); + const hits = pdfFindMatchRuns( + elements.map((element) => (element.tagName === "BR" ? "\n" : (element.textContent ?? ""))), + props.query, ); - const text = runs.map((run) => run.text).join(""); - const query = props.query.toLowerCase(); - let match = query.trim() ? text.indexOf(query) : -1; - let offset = 0; - for (const run of runs) { - while (match !== -1 && match + query.length <= offset) - match = text.indexOf(query, match + query.length); - run.element.classList.toggle( - "pdf-find-match", - match !== -1 && match < offset + run.text.length, - ); - offset += run.text.length; - } + elements.forEach((element, index) => element.classList.toggle("pdf-find-match", hits[index])); }; mark(); const observer = new MutationObserver(mark); @@ -181,24 +180,10 @@ export default function PdfViewer(props: { src: string; title: string }) { update(); return observeResize(node, update); }, []); - const fitWidth = Math.max(1, viewport.width - 32); - const scale = zoom ?? fitWidth / pageWidth; - const width = zoom === null ? fitWidth : pageWidth * zoom; - const offsets = (() => { - const result = [16]; - for (const ratio of ratios) result.push(result[result.length - 1]! + width * ratio + 16); - return result; - })(); - const current = Math.max( - 0, - ratios.findIndex((_, index) => offsets[index + 1]! > scrollTop + 17), - ); - const visible = ratios.flatMap((ratio, index) => - offsets[index + 1]! >= scrollTop - viewport.height && - offsets[index]! <= scrollTop + viewport.height * 2 - ? [{ index, ratio }] - : [], - ); + const { scale, width } = pdfPageWidth(viewport.width, pageWidth, zoom); + const offsets = pdfPageOffsets(ratios, width); + const current = currentPdfPage(offsets, ratios.length, scrollTop); + const visible = visiblePdfPages(ratios, offsets, scrollTop, viewport.height); // Stable callbacks let page canvases survive scroll and find updates. const [onSize] = useState( () => (index: number, ratio: number) => @@ -207,10 +192,10 @@ export default function PdfViewer(props: { src: string; title: string }) { ), ); const jumpToPage = useEffectEvent((index: number) => { - scroll.current?.scrollTo({ top: Math.max(0, (offsets[index] ?? 16) - 16) }); + scroll.current?.scrollTo({ top: pdfPageScrollTop(offsets, index) }); }); const showPage = (index: number) => { - scroll.current?.scrollTo({ top: Math.max(0, (offsets[index] ?? 16) - 16) }); + scroll.current?.scrollTo({ top: pdfPageScrollTop(offsets, index) }); }; const changeZoom = (value: number | null) => { zoomAnchor.current = { @@ -256,9 +241,7 @@ export default function PdfViewer(props: { src: string; title: string }) { const pageSize = page.getViewport({ scale: 1 }); sizes.push(pageSize.height / pageSize.width); const content = await page.getTextContent(); - const text = content.items - .map((item) => ("str" in item ? item.str + (item.hasEOL ? "\n" : "") : "")) - .join(""); + const text = pdfPageText(content.items); size += text.length; if (size > MAX_FIND_TEXT) throw new Error( @@ -305,8 +288,8 @@ export default function PdfViewer(props: { src: string; title: string }) { changeZoom(Math.max(0.25, scale - 0.25))} + disabled={scale <= PDF_MIN_ZOOM} + onPress={() => changeZoom(stepPdfZoom(scale, -1))} > @@ -315,8 +298,8 @@ export default function PdfViewer(props: { src: string; title: string }) { = 3} - onPress={() => changeZoom(Math.min(3, scale + 0.25))} + disabled={scale >= PDF_MAX_ZOOM} + onPress={() => changeZoom(stepPdfZoom(scale, 1))} > diff --git a/apps/web/src/components/files/pdfLayout.test.ts b/apps/web/src/components/files/pdfLayout.test.ts new file mode 100644 index 0000000000000..e0822a451e7d1 --- /dev/null +++ b/apps/web/src/components/files/pdfLayout.test.ts @@ -0,0 +1,113 @@ +import { describe, expect, it } from "vite-plus/test"; +import { + currentPdfPage, + pdfFindMatchRuns, + pdfPageOffsets, + pdfPageScrollTop, + pdfPageText, + pdfPageWidth, + stepPdfZoom, + visiblePdfPages, +} from "./pdfLayout"; + +describe("pdfPageWidth", () => { + it("fits the page to the viewport minus its gutters until a zoom is chosen", () => { + expect(pdfPageWidth(500, 612, null)).toEqual({ width: 468, scale: 468 / 612 }); + expect(pdfPageWidth(500, 612, 1.5)).toEqual({ width: 918, scale: 1.5 }); + }); + + it("never collapses below one pixel in a tiny viewport", () => { + expect(pdfPageWidth(10, 612, null).width).toBe(1); + }); +}); + +describe("stepPdfZoom", () => { + it("steps by a quarter and clamps to 25%..300%", () => { + expect(stepPdfZoom(1, 1)).toBe(1.25); + expect(stepPdfZoom(1, -1)).toBe(0.75); + expect(stepPdfZoom(2.9, 1)).toBe(3); + expect(stepPdfZoom(0.3, -1)).toBe(0.25); + }); + + it("starts from the fit-width scale when no zoom is set", () => { + const { scale } = pdfPageWidth(500, 612, null); + expect(stepPdfZoom(scale, 1)).toBeCloseTo(468 / 612 + 0.25); + }); +}); + +describe("mixed-height page layout", () => { + // A short banner page, a letter page, then a page half as tall as it is wide. + const ratios = [140 / 612, 792 / 612, 306 / 612]; + const width = 612; + const offsets = pdfPageOffsets(ratios, width); + + it("stacks pages with a gap before, between, and after them", () => { + expect(offsets).toEqual([16, 172, 980, 1302]); + }); + + it("reports the page whose bottom is past the top gutter as current", () => { + expect(currentPdfPage(offsets, 3, 0)).toBe(0); + expect(currentPdfPage(offsets, 3, 154)).toBe(0); + expect(currentPdfPage(offsets, 3, 155)).toBe(1); + expect(currentPdfPage(offsets, 3, 962)).toBe(1); + expect(currentPdfPage(offsets, 3, 964)).toBe(2); + }); + + it("jumps to each page so that page becomes current", () => { + for (const index of [0, 1, 2]) + expect(currentPdfPage(offsets, 3, pdfPageScrollTop(offsets, index))).toBe(index); + expect(pdfPageScrollTop(offsets, 7)).toBe(0); + }); + + it("mounts pages within a viewport above and two below", () => { + const indexes = (scrollTop: number, height: number) => + visiblePdfPages(ratios, offsets, scrollTop, height).map((page) => page.index); + expect(indexes(0, 100)).toEqual([0, 1]); + expect(indexes(1100, 100)).toEqual([2]); + expect(indexes(1100, 900)).toEqual([1, 2]); + expect(visiblePdfPages(ratios, offsets, 0, 100)[0]).toEqual({ index: 0, ratio: ratios[0] }); + }); + + it("scales offsets with the page width when zoomed", () => { + expect(pdfPageOffsets(ratios, width * 2)).toEqual([16, 312, 1912, 2540]); + }); +}); + +describe("pdfPageText", () => { + it("joins text items, adds line ends, and skips marked content", () => { + expect( + pdfPageText([ + { str: "Quarter", hasEOL: false }, + { type: "beginMarkedContent" }, + { str: "ly outlook", hasEOL: true }, + { str: "Next", hasEOL: false }, + ]), + ).toBe("Quarterly outlook\nNext"); + }); +}); + +describe("pdfFindMatchRuns", () => { + it("highlights every run a match spans when a word is split across spans", () => { + expect(pdfFindMatchRuns(["Quarter", "ly outlook", " for Q3"], "quarterly OUTLOOK")).toEqual([ + true, + true, + false, + ]); + }); + + it("highlights each separate match", () => { + expect(pdfFindMatchRuns(["risk", " and ", "budget", " ", "Risk"], "risk")).toEqual([ + true, + false, + false, + false, + true, + ]); + }); + + it("highlights nothing for a blank or missing query", () => { + expect(pdfFindMatchRuns(["a b", "c"], " ")).toEqual([false, false]); + expect(pdfFindMatchRuns(["a b", "c"], "")).toEqual([false, false]); + expect(pdfFindMatchRuns(["a b", "c"], "zzz")).toEqual([false, false]); + }); +}); diff --git a/apps/web/src/components/files/pdfLayout.ts b/apps/web/src/components/files/pdfLayout.ts new file mode 100644 index 0000000000000..a539260f02306 --- /dev/null +++ b/apps/web/src/components/files/pdfLayout.ts @@ -0,0 +1,73 @@ +const PDF_PAGE_GAP = 16; +export const PDF_MIN_ZOOM = 0.25; +export const PDF_MAX_ZOOM = 3; +const PDF_ZOOM_STEP = 0.25; + +export function pdfPageWidth(viewportWidth: number, pageWidth: number, zoom: number | null) { + const fitWidth = Math.max(1, viewportWidth - 2 * PDF_PAGE_GAP); + return { + scale: zoom ?? fitWidth / pageWidth, + width: zoom === null ? fitWidth : pageWidth * zoom, + }; +} + +export function stepPdfZoom(scale: number, direction: 1 | -1) { + return direction > 0 + ? Math.min(PDF_MAX_ZOOM, scale + PDF_ZOOM_STEP) + : Math.max(PDF_MIN_ZOOM, scale - PDF_ZOOM_STEP); +} + +/** Top offset of each page plus the end of the last one; ratios are height / width. */ +export function pdfPageOffsets(ratios: readonly number[], width: number) { + const result = [PDF_PAGE_GAP]; + for (const ratio of ratios) + result.push(result[result.length - 1]! + width * ratio + PDF_PAGE_GAP); + return result; +} + +export function currentPdfPage(offsets: readonly number[], pageCount: number, scrollTop: number) { + for (let index = 0; index < pageCount; index++) + if (offsets[index + 1]! > scrollTop + PDF_PAGE_GAP + 1) return index; + return 0; +} + +/** Pages within one viewport above and two below the visible area stay mounted. */ +export function visiblePdfPages( + ratios: readonly number[], + offsets: readonly number[], + scrollTop: number, + viewportHeight: number, +) { + return ratios.flatMap((ratio, index) => + offsets[index + 1]! >= scrollTop - viewportHeight && + offsets[index]! <= scrollTop + viewportHeight * 2 + ? [{ index, ratio }] + : [], + ); +} + +export function pdfPageScrollTop(offsets: readonly number[], index: number) { + return Math.max(0, (offsets[index] ?? PDF_PAGE_GAP) - PDF_PAGE_GAP); +} + +export function pdfPageText( + items: readonly ({ str: string; hasEOL: boolean } | { type: string })[], +) { + return items.map((item) => ("str" in item ? item.str + (item.hasEOL ? "\n" : "") : "")).join(""); +} + +/** Which text runs hold part of a case-insensitive match, when pdf.js splits words across spans. */ +export function pdfFindMatchRuns(runs: readonly string[], query: string) { + const texts = runs.map((run) => run.toLowerCase()); + const text = texts.join(""); + const needle = query.toLowerCase(); + let match = needle.trim() ? text.indexOf(needle) : -1; + let offset = 0; + return texts.map((run) => { + while (match !== -1 && match + needle.length <= offset) + match = text.indexOf(needle, match + needle.length); + const hit = match !== -1 && match < offset + run.length; + offset += run.length; + return hit; + }); +} From 0623d09aeed210c77b6b149359f630983d90fe05 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 26 Oct 2026 17:09:17 -0700 Subject: [PATCH 3/9] refactor(mobile): drop the unreachable pending-task editor from new-task drafts (#25684) Co-authored-by: Claude Opus 5.5 --- apps/mobile/src/Stack.tsx | 13 +- .../threads/NewTaskDraftRouteScreen.tsx | 6 +- .../features/threads/NewTaskDraftScreen.tsx | 66 +---- .../threads/new-task-flow-provider.tsx | 257 ++--------------- .../features/threads/thread-route-state.ts | 2 - .../threads/use-legacy-plan-mode-enabled.ts | 3 +- apps/mobile/src/state/legacy-plan-mode.ts | 12 +- .../state/pending-task-editor-writes.test.ts | 272 ------------------ .../src/state/pending-task-editor-writes.ts | 81 ------ 9 files changed, 36 insertions(+), 676 deletions(-) delete mode 100644 apps/mobile/src/state/pending-task-editor-writes.test.ts delete mode 100644 apps/mobile/src/state/pending-task-editor-writes.ts diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx index fab1f307b04c4..1ea67736ab1e6 100644 --- a/apps/mobile/src/Stack.tsx +++ b/apps/mobile/src/Stack.tsx @@ -500,16 +500,11 @@ function RootStackLayout(props: { ); const draftRoute = props.state.routes.findLast((route) => route.name === "Thread"); const draftParams = ( - draftRoute?.params as - | { draft?: { draftId?: string | string[]; pendingTaskId?: string | string[] } } - | undefined + draftRoute?.params as { draft?: { draftId?: string | string[] } } | undefined )?.draft; const routeDraftId = Array.isArray(draftParams?.draftId) ? draftParams.draftId[0] : draftParams?.draftId; - const routePendingTaskId = Array.isArray(draftParams?.pendingTaskId) - ? draftParams.pendingTaskId[0] - : draftParams?.pendingTaskId; useAgentNotificationNavigation(workspaceLocation.pathname); useConnectOnboardingNavigation(); useAppShortcuts(props.state); @@ -531,11 +526,7 @@ function RootStackLayout(props: { }, [navigation, pendingShare, props.state]); return ( - + diff --git a/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx index 059f6ff2b12c3..73a43b7340d74 100644 --- a/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskDraftRouteScreen.tsx @@ -40,9 +40,6 @@ export function NewTaskDraftRouteScreen({ route }: StaticScreenProps )} diff --git a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx index 5efbf0a45ccb1..66a041c3f3fc3 100644 --- a/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskDraftScreen.tsx @@ -150,7 +150,6 @@ export function NewTaskDraftScreen(props: { readonly worktreePath?: string | null; readonly cloning?: boolean; }; - readonly pendingTaskId?: string; readonly draftId?: string; readonly incomingShareId?: string; }) { @@ -386,11 +385,11 @@ export function NewTaskDraftScreen(props: { }; }, []); - const { beginEditingPendingTask, cancelEditingPendingTask, editingPendingTask, openDraft } = flow; + const { openDraft } = flow; // Cold launches load drafts and projects separately; wait for hydration and retry while shells load. const attemptedDraftIdRef = useRef(null); useEffect(() => { - if (!props.draftId || props.pendingTaskId) { + if (!props.draftId) { return; } const draftId = props.draftId; @@ -415,34 +414,12 @@ export function NewTaskDraftScreen(props: { return () => { cancelled = true; }; - }, [navigation, openDraft, projects, props.draftId, props.pendingTaskId]); - - const attemptedPendingTaskIdRef = useRef(null); - useEffect(() => { - if (!props.pendingTaskId || editingPendingTask?.messageId === props.pendingTaskId) { - return; - } - if (attemptedPendingTaskIdRef.current === props.pendingTaskId) { - return; - } - attemptedPendingTaskIdRef.current = props.pendingTaskId; - if (!beginEditingPendingTask(props.pendingTaskId)) { - navigation.dispatch(CommonActions.navigate("NewTaskProject")); - } - }, [beginEditingPendingTask, editingPendingTask?.messageId, navigation, props.pendingTaskId]); - - useEffect(() => { - if (!props.pendingTaskId) return; - return () => { - attemptedPendingTaskIdRef.current = null; - cancelEditingPendingTask(); - }; - }, [props.pendingTaskId, cancelEditingPendingTask]); + }, [navigation, openDraft, projects, props.draftId]); const lastInitialProjectRefRef = useRef(props.initialProjectRef); useEffect(() => { - if (props.pendingTaskId || props.draftId) { + if (props.draftId) { return; } if (lastInitialProjectRefRef.current !== props.initialProjectRef) { @@ -516,9 +493,8 @@ export function NewTaskDraftScreen(props: { projects, flow.draftKey, props.initialProjectRef, - // oxlint-disable-next-line react/exhaustive-effect-dependencies -- Opening a draft from a share, pending task, or draft id re-resolves its project. + // oxlint-disable-next-line react/exhaustive-effect-dependencies -- Opening a draft from a share or draft id re-resolves its project. props.incomingShareId, - props.pendingTaskId, props.draftId, navigation, selectedProject, @@ -901,17 +877,7 @@ export function NewTaskDraftScreen(props: { return null; } - const editingPendingTask = flow.editingPendingTask; - - const metadata = editingPendingTask - ? { - threadId: editingPendingTask.threadId, - commandId: editingPendingTask.commandId, - messageId: editingPendingTask.messageId, - createdAt: editingPendingTask.createdAt, - } - : creationMetadata; - const message = flow.buildPendingTaskMessage(metadata, { + const message = flow.buildPendingTaskMessage(creationMetadata, { currentCheckoutBranch: queuesInsteadOfStarting ? null : flow.currentCheckoutBranchName, }); if (!message) { @@ -939,17 +905,13 @@ export function NewTaskDraftScreen(props: { // would otherwise resurrect this draft. abortComposerDraftOperations(draftKey); const draftSnapshot = getComposerDraftSnapshot(draftKey); - if (editingPendingTask) { - flow.finishEditingPendingTask(); - } else { - // The queued message owns the attachments now, so the sweep is deferred - // until the write confirms it. - clearComposerDraftContent(draftKey, { - clearModelSelection: true, - clearWorkspaceSelection: true, - deferAttachmentCleanup: true, - }); - } + // The queued message owns the attachments now, so the sweep is deferred + // until the write confirms it. + clearComposerDraftContent(draftKey, { + clearModelSelection: true, + clearWorkspaceSelection: true, + deferAttachmentCleanup: true, + }); scheduleUnusedComposerAttachmentCleanup(draftSnapshot.attachments); return message.messageId; } @@ -1146,7 +1108,7 @@ export function NewTaskDraftScreen(props: { const thread = draftThreadShell({ environmentId: selectedProject.environmentId, projectId: selectedProject.id, - threadId: ThreadId.make(flow.editingPendingTask?.threadId ?? creationMetadata.threadId), + threadId: ThreadId.make(creationMetadata.threadId), modelSelection: flow.selectedModel, runtimeMode: flow.runtimeMode, interactionMode: flow.interactionMode, diff --git a/apps/mobile/src/features/threads/new-task-flow-provider.tsx b/apps/mobile/src/features/threads/new-task-flow-provider.tsx index 43017bfc74739..a7417328e6550 100644 --- a/apps/mobile/src/features/threads/new-task-flow-provider.tsx +++ b/apps/mobile/src/features/threads/new-task-flow-provider.tsx @@ -17,7 +17,6 @@ import type { import { CommandId, DEFAULT_PROVIDER_INTERACTION_MODE, - DEFAULT_RUNTIME_MODE, DEFAULT_SERVER_SETTINGS, MessageId, repositoryGroupingKeyOf, @@ -54,43 +53,26 @@ import { useAtomCommand } from "../../state/use-atom-command"; import { appendComposerDraftAttachments, type ComposerDraftInsertion, - clearComposerDraft, composerDraftsAtom, createNewTaskDraft, getComposerDraftSnapshot, - isComposerDraftEmpty, isNewTaskDraftKey, removeComposerDraftAttachment, replaceComposerDraftAttachments, retargetNewTaskDraft, - scheduleUnusedComposerAttachmentCleanup, setComposerDraftText, - setComposerDraftContext, setStickyComposerModelSelection, updateComposerDraftSettings, useComposerDraft, useStickyComposerModelSelection, } from "../../state/use-composer-drafts"; -import { - capturePendingTaskEditorWriteBaseline, - flushPendingTaskEditorWrite, -} from "../../state/pending-task-editor-writes"; import { rememberModelOptions, withRememberedModelOptions, } from "../../state/use-model-option-memory"; import { useBranches, usePaginatedBranches } from "../../state/queries"; import { vcsEnvironment } from "../../state/vcs"; -import { - flattenQueuedThreadMessages, - threadOutboxManager, - type QueuedThreadMessage, -} from "../../state/thread-outbox"; -import { - holdEditingQueuedMessage, - releaseEditingQueuedMessage, - useThreadOutboxMessages, -} from "../../state/use-thread-outbox"; +import { type QueuedThreadMessage } from "../../state/thread-outbox"; import { setPendingConnectionError, useRemoteConnectionStatus, @@ -126,20 +108,6 @@ import { useOlderSettledCount } from "../../state/olderSettledShelf"; type WorkspaceMode = "local" | "worktree"; -function pendingTaskDraftKey(messageId: string): string { - return `pending-task:${messageId}`; -} - -// Track ownership across providers so old unmount flushes cannot drop newer drafts or drain locks. -let activeEditingMessageId: string | null = null; - -function findQueuedPendingTask(messageId: string): QueuedThreadMessage | null { - const message = flattenQueuedThreadMessages( - appAtomRegistry.get(threadOutboxManager.queuedMessagesByThreadKeyAtom), - ).find((candidate) => candidate.messageId === messageId); - return message?.creation !== undefined ? message : null; -} - export function branchBadgeLabel(input: { readonly branch: VcsRef; readonly project: EnvironmentProject | null; @@ -174,7 +142,6 @@ type NewTaskFlowContextValue = { readonly startFromOrigin: boolean; readonly pullRequestReference: string | undefined; readonly draftKey: string | null; - readonly editingPendingTask: QueuedThreadMessage | null; readonly prompt: string; readonly attachments: ReadonlyArray; readonly submitting: boolean; @@ -210,9 +177,6 @@ type NewTaskFlowContextValue = { readonly setWorkspaceMode: (mode: WorkspaceMode) => void; readonly selectBranch: (branch: VcsRef) => void; readonly setStartFromOrigin: (value: boolean) => void; - readonly beginEditingPendingTask: (messageId: string) => boolean; - readonly finishEditingPendingTask: () => void; - readonly cancelEditingPendingTask: () => void; readonly buildPendingTaskMessage: ( metadata: TurnCommandMetadata, options?: { @@ -244,15 +208,13 @@ export function NewTaskFlowProvider( props: React.PropsWithChildren<{ active?: boolean; routeDraftId?: string; - routePendingTaskId?: string; }>, ) { const projects = useProjects(); const threads = useThreadShells(); const { savedConnectionsById } = useSavedRemoteConnections(); const groupingSettings = useMobileProjectGroupingSettings(); - const { enabled: legacyPlanModeEnabled, loaded: planModePreferenceLoaded } = - useLegacyPlanModeState(); + const { enabled: legacyPlanModeEnabled } = useLegacyPlanModeState(); const projectScopes = sortHomeProjectScopes({ scopes: buildHomeProjectScopes({ @@ -277,11 +239,7 @@ export function NewTaskFlowProvider( const [activeDraftKey, setActiveDraftKey] = useState(null); const [submitting, setSubmitting] = useState(false); const [expandedProvider, setExpandedProvider] = useState(null); - const [editingPendingTask, setEditingPendingTask] = useState(null); const pendingLocalBranchSyncDraftKeysRef = useRef(new Set()); - // Mirror edit state synchronously so unmount flush cannot save a session ended this render. - const editingPendingTaskRef = useRef(null); - const editingRevisionRef = useRef(Promise.resolve(0)); const reset = useCallback(() => { setSelectedEnvironmentId(null); @@ -290,15 +248,6 @@ export function NewTaskFlowProvider( setSubmitting(false); setExpandedProvider(null); pendingLocalBranchSyncDraftKeysRef.current.clear(); - const editing = editingPendingTaskRef.current; - editingPendingTaskRef.current = null; - setEditingPendingTask(null); - if (editing) { - if (activeEditingMessageId === editing.messageId) { - activeEditingMessageId = null; - } - releaseEditingQueuedMessage(editing.messageId); - } }, []); const projectsForEnvironment = pipe( @@ -306,34 +255,12 @@ export function NewTaskFlowProvider( Arr.filter((project) => project.environmentId === selectedEnvironmentId), ); - const editingPendingProject = ((): EnvironmentProject | null => { - const creation = editingPendingTask?.creation; - if (!editingPendingTask || !creation) { - return null; - } - return { - environmentId: editingPendingTask.environmentId, - id: creation.projectId, - title: creation.projectTitle ?? "Unknown project", - workspaceRoot: creation.projectCwd ?? "", - repositoryIdentity: null, - defaultModelSelection: editingPendingTask.modelSelection ?? null, - scripts: [], - createdAt: editingPendingTask.createdAt, - updatedAt: editingPendingTask.createdAt, - }; - })(); - const selectedProject = projectsForEnvironment.find( (project) => scopedProjectKey(project.environmentId, project.id) === selectedProjectKey, ) ?? - // Pin queued edits to their original project when its shell is missing; fallback would silently retarget them. - (editingPendingProject !== null && - selectedProjectKey === - scopedProjectKey(editingPendingProject.environmentId, editingPendingProject.id) - ? editingPendingProject - : (projectsForEnvironment[0] ?? null)); + projectsForEnvironment[0] ?? + null; const selectedEnvironmentServerConfig = useEnvironmentServerConfig( selectedProject?.environmentId ?? null, @@ -404,18 +331,9 @@ export function NewTaskFlowProvider( return result; })(); - const selectedProjectDraftKey = editingPendingTask - ? pendingTaskDraftKey(editingPendingTask.messageId) - : selectedProject - ? activeDraftKey - : null; + const selectedProjectDraftKey = selectedProject ? activeDraftKey : null; useEffect(() => { - if ( - props.active === false || - activeDraftKey !== null || - editingPendingTask !== null || - selectedProject === null - ) { + if (props.active === false || activeDraftKey !== null || selectedProject === null) { return; } // oxlint-disable-next-line react/set-state-in-effect -- Creates the persistent draft once the project selection is ready; the key must exist before the composer mounts. @@ -425,19 +343,15 @@ export function NewTaskFlowProvider( projectId: selectedProject.id, }), ); - }, [activeDraftKey, editingPendingTask, selectedProject, props.active]); + }, [activeDraftKey, selectedProject, props.active]); const activePendingKey = props.active === false ? null - : props.routePendingTaskId - ? `pending-task:${props.routePendingTaskId}` - : props.routeDraftId - ? `draft-task:${props.routeDraftId}` - : editingPendingTask - ? `pending-task:${editingPendingTask.messageId}` - : selectedProjectDraftKey - ? `draft-task:${selectedProjectDraftKey}` - : null; + : props.routeDraftId + ? `draft-task:${props.routeDraftId}` + : selectedProjectDraftKey + ? `draft-task:${selectedProjectDraftKey}` + : null; const activeNewTask = React.useMemo( () => (props.active === false ? null : { pendingKey: activePendingKey }), [props.active, activePendingKey], @@ -537,9 +451,7 @@ export function NewTaskFlowProvider( const draftStartFromOrigin = selectedProjectDraft.workspaceSelection?.startFromOrigin; const startFromOrigin = isGitRepo && (draftStartFromOrigin ?? projectSettings.settings.newWorktreesStartFromOrigin); - const defaultRuntimeMode = editingPendingTask - ? (editingPendingTask.runtimeMode ?? DEFAULT_RUNTIME_MODE) - : projectSettings.settings.defaultRuntimeMode; + const defaultRuntimeMode = projectSettings.settings.defaultRuntimeMode; const runtimeMode = selectedProjectDraft.runtimeMode ?? defaultRuntimeMode; // Antigravity keeps unavailable selections so sign-out or a catalog change @@ -687,7 +599,7 @@ export function NewTaskFlowProvider( const target = { environmentId: project.environmentId, projectId: project.id }; if (activeDraftKey !== null && isNewTaskDraftKey(activeDraftKey)) { retargetNewTaskDraft(activeDraftKey, target); - } else if (!editingPendingTaskRef.current) { + } else { setActiveDraftKey(createNewTaskDraft(target)); } }; @@ -914,39 +826,6 @@ export function NewTaskFlowProvider( } }; - const beginEditingPendingTask = (messageId: string): boolean => { - const message = findQueuedPendingTask(messageId); - if (!message?.creation) { - return false; - } - const draftKey = pendingTaskDraftKey(message.messageId); - if (isComposerDraftEmpty(getComposerDraftSnapshot(draftKey))) { - setComposerDraftText(draftKey, message.text); - setComposerDraftContext(draftKey, message.context); - replaceComposerDraftAttachments(draftKey, message.attachments); - updateComposerDraftSettings(draftKey, { - modelSelection: message.modelSelection, - runtimeMode: message.runtimeMode, - interactionMode: message.interactionMode, - workspaceSelection: { - mode: message.creation.workspaceMode, - branch: message.creation.branch, - worktreePath: message.creation.worktreePath, - startFromOrigin: message.creation.startFromOrigin ?? false, - pullRequestReference: message.creation.pullRequestReference, - }, - }); - } - setSelectedEnvironmentId(message.environmentId); - setSelectedProjectKey(scopedProjectKey(message.environmentId, message.creation.projectId)); - activeEditingMessageId = message.messageId; - editingPendingTaskRef.current = message; - editingRevisionRef.current = capturePendingTaskEditorWriteBaseline(message.messageId); - setEditingPendingTask(message); - holdEditingQueuedMessage(message.messageId); - return true; - }; - const buildPendingTaskMessage = ( metadata: TurnCommandMetadata, options?: { readonly currentCheckoutBranch?: string | null }, @@ -980,17 +859,6 @@ export function NewTaskFlowProvider( isGitRepo, }); const mode = workspaceSelection.mode; - // When the selection is the stand-in built from the queued snapshot, - // persist the original (possibly absent) snapshot values — the - // stand-in's placeholder title/workspaceRoot must never be written back - // as if they were real project metadata. - const usingPendingSnapshot = selectedProject === editingPendingProject; - const projectTitle = usingPendingSnapshot - ? editingPendingTask?.creation?.projectTitle - : selectedProject.title; - const projectCwd = usingPendingSnapshot - ? editingPendingTask?.creation?.projectCwd - : selectedProject.workspaceRoot; return { environmentId: selectedProject.environmentId, threadId: ThreadId.make(metadata.threadId), @@ -1002,18 +870,16 @@ export function NewTaskFlowProvider( modelSelection: draftModelSelection, runtimeMode: draft.runtimeMode ?? defaultRuntimeMode, interactionMode: resolvePendingTaskInteractionMode({ - preferenceLoaded: planModePreferenceLoaded, planModeEnabled: legacyPlanModeEnabled, draftInteractionMode: draft.interactionMode, - queuedInteractionMode: editingPendingTask?.interactionMode, provider: selectedEnvironmentServerConfig?.providers.find( (candidate) => candidate.instanceId === draftModelSelection.instanceId, ), }), creation: { projectId: selectedProject.id, - ...(projectTitle !== undefined ? { projectTitle } : {}), - ...(projectCwd !== undefined ? { projectCwd } : {}), + projectTitle: selectedProject.title, + projectCwd: selectedProject.workspaceRoot, workspaceMode: mode, ...(mode === "worktree" && workspaceSelection?.pullRequestReference ? { pullRequestReference: workspaceSelection.pullRequestReference } @@ -1033,93 +899,6 @@ export function NewTaskFlowProvider( }; }; - const finishEditingPendingTask = () => { - const editing = editingPendingTaskRef.current; - editingPendingTaskRef.current = null; - if (editing) { - if (activeEditingMessageId === editing.messageId) { - activeEditingMessageId = null; - } - clearComposerDraft(pendingTaskDraftKey(editing.messageId)); - releaseEditingQueuedMessage(editing.messageId); - scheduleUnusedComposerAttachmentCleanup(editing.attachments); - } - setEditingPendingTask(null); - }; - - // End editing without saving if the queued task disappears; a later flush must not resurrect it. - const queuedMessagesByThreadKey = useThreadOutboxMessages(); - useEffect(() => { - const editing = editingPendingTaskRef.current; - if (!editing) { - return; - } - const stillQueued = flattenQueuedThreadMessages(queuedMessagesByThreadKey).some( - (candidate) => candidate.messageId === editing.messageId, - ); - if (!stillQueued) { - finishEditingPendingTask(); - } - }, [finishEditingPendingTask, queuedMessagesByThreadKey]); - - const editingFlushRef = useRef<(() => void) | null>(null); - useEffect(() => { - editingFlushRef.current = () => { - const editing = editingPendingTaskRef.current; - if (!editing) { - return; - } - editingPendingTaskRef.current = null; - setEditingPendingTask(null); - if (activeEditingMessageId === editing.messageId) { - activeEditingMessageId = null; - } - - const message = buildPendingTaskMessage({ - threadId: editing.threadId, - commandId: editing.commandId, - messageId: editing.messageId, - createdAt: editing.createdAt, - }); - - if (!message) { - // Keep unsendable edits and the drain lock so removed content cannot auto-send from a stale payload. - return; - } - - // Hand off pending saves to reopened editors; CAS still rejects unrelated edits, deletes and deliveries. - void flushPendingTaskEditorWrite({ - message, - baseline: editingRevisionRef.current, - draftKey: pendingTaskDraftKey(editing.messageId), - }) - .then((savedDraftStillCurrent) => { - if (activeEditingMessageId === editing.messageId) { - return; - } - if (!savedDraftStillCurrent) { - return; - } - clearComposerDraft(pendingTaskDraftKey(editing.messageId)); - releaseEditingQueuedMessage(editing.messageId); - scheduleUnusedComposerAttachmentCleanup(editing.attachments); - }) - .catch((error) => { - // Keep the draft and drain lock on failure so stale payloads cannot discard edits; reopening retries. - console.warn("[new-task] failed to save edited pending task", error); - }); - }; - }, [buildPendingTaskMessage]); - const cancelEditingPendingTask = () => { - editingFlushRef.current?.(); - }; - useEffect( - () => () => { - editingFlushRef.current?.(); - }, - [], - ); - const value = { activeNewTask, projectScopes, @@ -1135,7 +914,6 @@ export function NewTaskFlowProvider( startFromOrigin, draftKey: selectedProjectDraftKey, pullRequestReference: selectedProjectDraft.workspaceSelection?.pullRequestReference, - editingPendingTask, prompt, attachments, submitting, @@ -1164,9 +942,6 @@ export function NewTaskFlowProvider( setWorkspaceMode, selectBranch, setStartFromOrigin, - beginEditingPendingTask, - finishEditingPendingTask, - cancelEditingPendingTask, buildPendingTaskMessage, setPrompt, replaceAttachments, diff --git a/apps/mobile/src/features/threads/thread-route-state.ts b/apps/mobile/src/features/threads/thread-route-state.ts index c9a6ab6a3ddba..e237d9bf69937 100644 --- a/apps/mobile/src/features/threads/thread-route-state.ts +++ b/apps/mobile/src/features/threads/thread-route-state.ts @@ -6,7 +6,6 @@ export type NewTaskDraftRouteParams = { readonly worktreePath?: string | null; readonly title?: string | string[]; readonly cloning?: string | string[]; - readonly pendingTaskId?: string | string[]; readonly draftId?: string | string[]; readonly incomingShareId?: string | string[]; }; @@ -32,7 +31,6 @@ export function draftRouteIdentity(draft: NewTaskDraftRouteParams): string { const first = (value: string | string[] | undefined) => (Array.isArray(value) ? value[0] : value); return JSON.stringify([ draft.requestId, - first(draft.pendingTaskId), first(draft.draftId), first(draft.environmentId), first(draft.projectId), diff --git a/apps/mobile/src/features/threads/use-legacy-plan-mode-enabled.ts b/apps/mobile/src/features/threads/use-legacy-plan-mode-enabled.ts index 5f41874588b0a..694a34e632e3f 100644 --- a/apps/mobile/src/features/threads/use-legacy-plan-mode-enabled.ts +++ b/apps/mobile/src/features/threads/use-legacy-plan-mode-enabled.ts @@ -4,7 +4,7 @@ import { AsyncResult } from "effect/reactivity"; import { mobilePreferencesAtom } from "../../state/preferences"; import { resolveLegacyPlanModeEnabled } from "../../state/legacy-plan-mode"; -export function useLegacyPlanModeState(): { readonly enabled: boolean; readonly loaded: boolean } { +export function useLegacyPlanModeState(): { readonly enabled: boolean } { const preferences = useAtomValue(mobilePreferencesAtom); const loaded = AsyncResult.isSuccess(preferences); return { @@ -12,6 +12,5 @@ export function useLegacyPlanModeState(): { readonly enabled: boolean; readonly loaded, preference: loaded ? preferences.value.planModeEnabled : undefined, }), - loaded, }; } diff --git a/apps/mobile/src/state/legacy-plan-mode.ts b/apps/mobile/src/state/legacy-plan-mode.ts index d768d4dac351c..f4ab2f8c681c2 100644 --- a/apps/mobile/src/state/legacy-plan-mode.ts +++ b/apps/mobile/src/state/legacy-plan-mode.ts @@ -23,20 +23,12 @@ export function resolveLegacyPlanModeEnabled(input: { } export function resolvePendingTaskInteractionMode(input: { - readonly preferenceLoaded: boolean; readonly planModeEnabled: boolean; readonly draftInteractionMode: ProviderInteractionMode | undefined; - readonly queuedInteractionMode: ProviderInteractionMode | undefined; readonly provider?: InteractionModeProvider | null; }): ProviderInteractionMode { - if (input.provider?.showInteractionModeToggle === false) { + if (input.provider?.showInteractionModeToggle === false || !input.planModeEnabled) { return DEFAULT_PROVIDER_INTERACTION_MODE; } - if (input.planModeEnabled) { - return input.draftInteractionMode ?? DEFAULT_PROVIDER_INTERACTION_MODE; - } - if (!input.preferenceLoaded) { - return input.queuedInteractionMode ?? DEFAULT_PROVIDER_INTERACTION_MODE; - } - return DEFAULT_PROVIDER_INTERACTION_MODE; + return input.draftInteractionMode ?? DEFAULT_PROVIDER_INTERACTION_MODE; } diff --git a/apps/mobile/src/state/pending-task-editor-writes.test.ts b/apps/mobile/src/state/pending-task-editor-writes.test.ts deleted file mode 100644 index 8cdfc006a815e..0000000000000 --- a/apps/mobile/src/state/pending-task-editor-writes.test.ts +++ /dev/null @@ -1,272 +0,0 @@ -import { CommandId, EnvironmentId, MessageId, ThreadId } from "@t3tools/contracts"; -import { beforeEach, describe, expect, it, vi } from "vite-plus/test"; - -import type { QueuedThreadMessage } from "./thread-outbox-model"; - -const harness = vi.hoisted(() => ({ - manager: null as unknown as ReturnType< - typeof import("./thread-outbox-manager").createThreadOutboxManager - >, - writeGates: [] as Array<{ - readonly promise: Promise; - readonly started: (message: QueuedThreadMessage) => void; - }>, -})); - -vi.mock("./thread-outbox", async () => { - const { createThreadOutboxManager } = await import("./thread-outbox-manager"); - const { appAtomRegistry } = await import("./atom-registry"); - harness.manager = createThreadOutboxManager({ - registry: appAtomRegistry, - storage: { - load: async () => ({ messages: [], errors: [] }), - write: async (message) => { - const pending = harness.writeGates.shift(); - if (pending) { - pending.started(message); - await pending.promise; - } - }, - remove: async () => undefined, - }, - }); - const manager = harness.manager; - return { - threadOutboxManager: manager, - flushThreadOutbox: async () => undefined, - threadOutboxRevision: (messageId: QueuedThreadMessage["messageId"]) => - manager.revisionOf(messageId), - updateThreadOutboxMessage: (message: QueuedThreadMessage, expectedRevision?: number) => - manager.update(message, expectedRevision), - }; -}); - -import { appAtomRegistry } from "./atom-registry"; -import { - capturePendingTaskEditorWriteBaseline, - flushPendingTaskEditorWrite, -} from "./pending-task-editor-writes"; -import { - composerDraftsAtom, - getComposerDraftSnapshot, - type ComposerDraft, -} from "./use-composer-drafts"; - -function queuedMessage(messageId: string, text: string): QueuedThreadMessage { - return { - environmentId: EnvironmentId.make("environment-1"), - threadId: ThreadId.make("thread-1"), - messageId: MessageId.make(messageId), - commandId: CommandId.make(`command-${messageId}`), - text, - attachments: [], - createdAt: "2026-08-28T12:00:00.000Z", - }; -} - -function draft(text: string): ComposerDraft { - return { - text, - attachments: [], - runtimeMode: "full-access", - }; -} - -function setDraft(draftKey: string, value: ComposerDraft): void { - appAtomRegistry.set(composerDraftsAtom, { [draftKey]: value }); -} - -function queuedMessageText(messageId: QueuedThreadMessage["messageId"]): string | null { - const messages = Object.values( - appAtomRegistry.get(harness.manager.queuedMessagesByThreadKeyAtom), - ).flat(); - return messages.find((message) => message.messageId === messageId)?.text ?? null; -} - -function blockNextWrite() { - let resolveWrite!: () => void; - let rejectWrite!: (error: Error) => void; - let markStarted!: (message: QueuedThreadMessage) => void; - const promise = new Promise((resolve, reject) => { - resolveWrite = resolve; - rejectWrite = reject; - }); - const started = new Promise((resolve) => { - markStarted = resolve; - }); - harness.writeGates.push({ promise, started: markStarted }); - return { - started, - resolve: resolveWrite, - reject: rejectWrite, - }; -} - -beforeEach(() => { - harness.writeGates.length = 0; - appAtomRegistry.set(harness.manager.queuedMessagesByThreadKeyAtom, {}); - appAtomRegistry.set(composerDraftsAtom, {}); -}); - -describe("pending task editor writes", () => { - it("chains a reopened editor that closes before the previous save finishes", async () => { - const original = queuedMessage("message-close-before-save", "original"); - const firstEdit = queuedMessage("message-close-before-save", "first edit"); - const secondEdit = queuedMessage("message-close-before-save", "second edit"); - const draftKey = "pending-task:message-close-before-save"; - await harness.manager.enqueue(original); - - setDraft(draftKey, draft(firstEdit.text)); - const firstBaseline = capturePendingTaskEditorWriteBaseline(original.messageId); - const firstWriteGate = blockNextWrite(); - const firstSave = flushPendingTaskEditorWrite({ - message: firstEdit, - baseline: firstBaseline, - draftKey, - }); - await firstWriteGate.started; - - const secondBaseline = capturePendingTaskEditorWriteBaseline(original.messageId); - setDraft(draftKey, draft(secondEdit.text)); - const secondWriteGate = blockNextWrite(); - const secondSave = flushPendingTaskEditorWrite({ - message: secondEdit, - baseline: secondBaseline, - draftKey, - }); - - firstWriteGate.resolve(); - await expect(firstSave).resolves.toBe(false); - await expect(secondWriteGate.started).resolves.toMatchObject({ text: secondEdit.text }); - secondWriteGate.resolve(); - - await expect(secondSave).resolves.toBe(true); - expect(queuedMessageText(original.messageId)).toBe(secondEdit.text); - }); - - it("keeps a captured predecessor after that predecessor finishes", async () => { - const original = queuedMessage("message-finished-predecessor", "original"); - const firstEdit = queuedMessage("message-finished-predecessor", "first edit"); - const secondEdit = queuedMessage("message-finished-predecessor", "second edit"); - const draftKey = "pending-task:message-finished-predecessor"; - await harness.manager.enqueue(original); - - setDraft(draftKey, draft(firstEdit.text)); - const firstWriteGate = blockNextWrite(); - const firstSave = flushPendingTaskEditorWrite({ - message: firstEdit, - baseline: capturePendingTaskEditorWriteBaseline(original.messageId), - draftKey, - }); - await firstWriteGate.started; - const secondBaseline = capturePendingTaskEditorWriteBaseline(original.messageId); - - firstWriteGate.resolve(); - await expect(firstSave).resolves.toBe(true); - - setDraft(draftKey, draft(secondEdit.text)); - const secondWriteGate = blockNextWrite(); - const secondSave = flushPendingTaskEditorWrite({ - message: secondEdit, - baseline: secondBaseline, - draftKey, - }); - await secondWriteGate.started; - secondWriteGate.resolve(); - - await expect(secondSave).resolves.toBe(true); - expect(queuedMessageText(original.messageId)).toBe(secondEdit.text); - }); - - it("keeps the handed-off revision when the middle editor write fails", async () => { - const original = queuedMessage("message-middle-failure", "original"); - const firstEdit = queuedMessage("message-middle-failure", "first edit"); - const failedEdit = queuedMessage("message-middle-failure", "failed edit"); - const finalEdit = queuedMessage("message-middle-failure", "final edit"); - const draftKey = "pending-task:message-middle-failure"; - await harness.manager.enqueue(original); - - setDraft(draftKey, draft(firstEdit.text)); - const firstWriteGate = blockNextWrite(); - const firstSave = flushPendingTaskEditorWrite({ - message: firstEdit, - baseline: capturePendingTaskEditorWriteBaseline(original.messageId), - draftKey, - }); - await firstWriteGate.started; - - const failedBaseline = capturePendingTaskEditorWriteBaseline(original.messageId); - setDraft(draftKey, draft(failedEdit.text)); - const failedWriteGate = blockNextWrite(); - const failedSave = flushPendingTaskEditorWrite({ - message: failedEdit, - baseline: failedBaseline, - draftKey, - }); - - const finalBaseline = capturePendingTaskEditorWriteBaseline(original.messageId); - setDraft(draftKey, draft(finalEdit.text)); - const finalWriteGate = blockNextWrite(); - const finalSave = flushPendingTaskEditorWrite({ - message: finalEdit, - baseline: finalBaseline, - draftKey, - }); - - firstWriteGate.resolve(); - await expect(firstSave).resolves.toBe(false); - await failedWriteGate.started; - failedWriteGate.reject(new Error("disk full")); - await expect(failedSave).rejects.toMatchObject({ _tag: "ThreadOutboxManagerError" }); - await finalWriteGate.started; - finalWriteGate.resolve(); - - await expect(finalSave).resolves.toBe(true); - expect(queuedMessageText(original.messageId)).toBe(finalEdit.text); - }); - - it("does not overwrite an unrelated update accepted after capture", async () => { - const original = queuedMessage("message-unrelated-update", "original"); - const editorEdit = queuedMessage("message-unrelated-update", "editor edit"); - const unrelatedEdit = queuedMessage("message-unrelated-update", "unrelated edit"); - const draftKey = "pending-task:message-unrelated-update"; - await harness.manager.enqueue(original); - - const editorBaseline = capturePendingTaskEditorWriteBaseline(original.messageId); - const revision = harness.manager.revisionOf(original.messageId); - await expect(harness.manager.update(unrelatedEdit, revision)).resolves.toBe(true); - setDraft(draftKey, draft(editorEdit.text)); - - await expect( - flushPendingTaskEditorWrite({ - message: editorEdit, - baseline: editorBaseline, - draftKey, - }), - ).resolves.toBe(false); - expect(queuedMessageText(original.messageId)).toBe(unrelatedEdit.text); - }); - - it("does not permit cleanup after a newer editor makes the draft unsendable", async () => { - const original = queuedMessage("message-unsendable-draft", "original"); - const editorEdit = queuedMessage("message-unsendable-draft", "saved edit"); - const draftKey = "pending-task:message-unsendable-draft"; - await harness.manager.enqueue(original); - - setDraft(draftKey, draft(editorEdit.text)); - const writeGate = blockNextWrite(); - const save = flushPendingTaskEditorWrite({ - message: editorEdit, - baseline: capturePendingTaskEditorWriteBaseline(original.messageId), - draftKey, - }); - await writeGate.started; - - setDraft(draftKey, draft("")); - writeGate.resolve(); - - await expect(save).resolves.toBe(false); - expect(getComposerDraftSnapshot(draftKey).text).toBe(""); - expect(queuedMessageText(original.messageId)).toBe(editorEdit.text); - }); -}); diff --git a/apps/mobile/src/state/pending-task-editor-writes.ts b/apps/mobile/src/state/pending-task-editor-writes.ts deleted file mode 100644 index 7fe61c30e4c3c..0000000000000 --- a/apps/mobile/src/state/pending-task-editor-writes.ts +++ /dev/null @@ -1,81 +0,0 @@ -import type { QueuedThreadMessage } from "./thread-outbox"; -import { threadOutboxRevision, updateThreadOutboxMessage } from "./thread-outbox"; -import { getComposerDraftSnapshot, sameComposerDraftState } from "./use-composer-drafts"; - -type PendingTaskEditorWriteResult = - | { - readonly status: "complete"; - readonly updated: boolean; - readonly nextRevision: number; - } - | { - readonly status: "failed"; - readonly error: unknown; - readonly nextRevision: number; - }; - -const pendingWrites = new Map< - QueuedThreadMessage["messageId"], - Promise ->(); - -/** Captures the editor revision and predecessor save; the promise survives clearing its map entry. */ -export function capturePendingTaskEditorWriteBaseline( - messageId: QueuedThreadMessage["messageId"], -): Promise { - const capturedRevision = threadOutboxRevision(messageId); - const predecessor = pendingWrites.get(messageId); - if (!predecessor) { - return Promise.resolve(capturedRevision); - } - return predecessor.then( - ({ nextRevision }) => Math.max(capturedRevision, nextRevision), - () => capturedRevision, - ); -} - -export function flushPendingTaskEditorWrite(input: { - readonly message: QueuedThreadMessage; - readonly baseline: Promise; - readonly draftKey: string; -}): Promise { - const { message } = input; - const draftSnapshot = getComposerDraftSnapshot(input.draftKey); - const write = input.baseline.then( - async (expectedRevision): Promise => { - try { - const updated = await updateThreadOutboxMessage(message, expectedRevision); - return { - status: "complete", - updated, - nextRevision: expectedRevision + (updated ? 1 : 0), - }; - } catch (error) { - // Failed writes do not advance the outbox; hand their expected revision to later editor saves. - return { - status: "failed", - error, - nextRevision: expectedRevision, - }; - } - }, - ); - - pendingWrites.set(message.messageId, write); - const removeWrite = (): void => { - if (pendingWrites.get(message.messageId) === write) { - pendingWrites.delete(message.messageId); - } - }; - void write.then(removeWrite, removeWrite); - - return write.then((result) => { - if (result.status === "failed") { - throw result.error; - } - return ( - result.updated && - sameComposerDraftState(draftSnapshot, getComposerDraftSnapshot(input.draftKey)) - ); - }); -} From bd3287b640a717513a44b1d23e362aed446a263f Mon Sep 17 00:00:00 2001 From: Theo Browne Date: Mon, 26 Oct 2026 17:09:30 -0700 Subject: [PATCH 4/9] feat(web): thread state lives at the end of the timeline, not stacked on the composer (#25401) Co-authored-by: Claude Opus 5.5 --- apps/web/src/components/ChatView.tsx | 156 +++--- apps/web/src/components/chat/ChatComposer.tsx | 132 +---- .../chat/ComposerActivityStatus.tsx | 23 - .../src/components/chat/ComposerBanner.tsx | 51 +- .../chat/ComposerBannerStack.browser.test.tsx | 44 +- .../components/chat/ComposerBannerStack.tsx | 284 ++-------- .../src/components/chat/ComposerFeedback.tsx | 1 - .../chat/ComposerServerUpdateStatus.tsx | 5 +- .../components/chat/ComposerTasksBadge.tsx | 236 -------- .../components/chat/ComposerUsageLimits.tsx | 1 - .../src/components/chat/MessagesTimeline.tsx | 24 +- .../src/components/chat/QueuedRunsControl.tsx | 520 +++++++++--------- .../components/chat/ThreadActivityBanners.tsx | 67 ++- apps/web/src/components/chat/ThreadNow.tsx | 104 ++++ .../src/components/chat/TimelineOverlays.tsx | 14 +- .../chat/TimelineToolActivityIcon.tsx | 4 + .../chat/TimelineWorkEntryRow.logic.ts | 1 + .../chat/UsageLimitRecoveryBanner.tsx | 1 - .../src/components/chat/V2ItemInspector.tsx | 5 +- .../chat/useAutoBalanceUpdateBanner.tsx | 2 +- .../components/chat/useProjectCloneBanner.tsx | 1 - .../chat/useSystemComposerBanners.tsx | 86 +-- .../components/chat/useThreadLifecycle.tsx | 24 +- .../src/components/chat/useTimelineFollow.ts | 16 + .../components/composerFooterLayout.test.ts | 29 - .../src/components/composerFooterLayout.ts | 5 +- apps/web/src/components/guest/GuestPage.tsx | 6 +- apps/web/src/performance.bench.ts | 24 +- apps/web/src/session-logic.test.ts | 239 +------- apps/web/src/session-logic.ts | 90 +-- apps/web/src/versionSkew.ts | 4 - docs/user/composer.md | 18 +- docs/user/providers-claude.md | 4 +- docs/user/updating.md | 9 +- 34 files changed, 712 insertions(+), 1518 deletions(-) delete mode 100644 apps/web/src/components/chat/ComposerActivityStatus.tsx delete mode 100644 apps/web/src/components/chat/ComposerTasksBadge.tsx create mode 100644 apps/web/src/components/chat/ThreadNow.tsx diff --git a/apps/web/src/components/ChatView.tsx b/apps/web/src/components/ChatView.tsx index 6d608595848ee..8bf2ab68558ca 100644 --- a/apps/web/src/components/ChatView.tsx +++ b/apps/web/src/components/ChatView.tsx @@ -86,7 +86,10 @@ import { resolveWorkflowOpening, workflowOpeningParentThreadId, } from "@t3tools/client-runtime/state/subagentRuntime"; -import { threadSupportsProviderHandoff } from "@t3tools/client-runtime/state/thread-workflows"; +import { + getUserQueuedThreadRuns, + threadSupportsProviderHandoff, +} from "@t3tools/client-runtime/state/thread-workflows"; import { resolvePendingHandoff } from "@t3tools/client-runtime/handoff"; import { HandoffRow } from "./chat/V2LifecycleRow"; import { @@ -126,8 +129,6 @@ import { useActiveThreadRef } from "../hooks/useActiveThreadRef"; import { composerRequiresModifier } from "../composer-logic"; import { derivePhase, - deriveActivePlanState, - selectComposerTasksPlan, deriveActiveWorkStartedAt, deriveCanInterruptRunningThread, findLatestProposedPlan, @@ -352,6 +353,8 @@ import { ChatTerminalDrawers } from "./chat/ChatTerminalDrawers"; import { ChatRightPanel } from "./chat/ChatRightPanel"; import { useDraftEnvironmentRouting } from "./chat/useDraftEnvironmentRouting"; import { branchMismatchBannerItem } from "./chat/ThreadActivityBanners"; +import { ThreadNow } from "./chat/ThreadNow"; +import { useDelayedStatus } from "../hooks/useDelayedStatus"; import { useTimelineFollow } from "./chat/useTimelineFollow"; import { type EnvironmentUnavailableState, @@ -512,6 +515,8 @@ export default function ChatView(props: ChatViewProps) { status: threadStatus, }); const threadDetailLoading = threadSyncPhase === "loading"; + // Held back briefly, so a quick sync does not flash a status line at the end of the timeline. + const delayedThreadSyncPhase = useDelayedStatus(routeThreadKey, threadSyncPhase); const activeProviderThread = serverProjection?.providerThreads.find( (thread) => thread.id === serverProjection.thread.activeProviderThreadId, ); @@ -989,30 +994,6 @@ export default function ChatView(props: ChatViewProps) { ); const latestRunSettled = isLatestRunSettled(activeLatestRun, activeRuntime); - const activePlan = deriveActivePlanState(serverProjection, activeActivityRun?.runId); - const activeActivityRunSettled = isLatestRunSettled(activeActivityRun, activeRuntime); - const composerTasksPlan = selectComposerTasksPlan( - serverProjection, - activePlan, - activeActivityRun?.runId ?? null, - activeActivityRunSettled, - ); - const activeComposerTasksProgress = (() => { - if (!composerTasksPlan) return null; - const live = !activeActivityRunSettled && composerTasksPlan.runId === activeActivityRun?.runId; - const totalSteps = composerTasksPlan.steps.length; - if (totalSteps === 0) return null; - const completedSteps = composerTasksPlan.steps.filter( - (step) => step.status === "completed", - ).length; - const step = - composerTasksPlan.steps.find((candidate) => candidate.status === "inProgress")?.step ?? - composerTasksPlan.steps.find((candidate) => candidate.status === "pending")?.step ?? - composerTasksPlan.steps.at(-1)!.step; - return { step, completedSteps, totalSteps, live }; - })(); - const activeComposerTaskSteps = - activeComposerTasksProgress && composerTasksPlan ? composerTasksPlan.steps : null; const activeThreadEnvironmentId = activeThread?.environmentId; const activeThreadProjectId = activeThread?.projectId; const activeProjectRef = @@ -2007,6 +1988,7 @@ export default function ChatView(props: ChatViewProps) { onTimelineAnchorReadyStable, onTimelineAnchorSizeChangedStable, onToolOutputCollapsedAtEndStable, + onTimelineFooterGrowStable, onIsAtEndChangeStable, anchorNewTurn, attachTimelineViewport, @@ -2185,22 +2167,11 @@ export default function ChatView(props: ChatViewProps) { modelStrip.offsetHeight + Number.parseFloat(getComputedStyle(modelStrip).marginTop), ) : 0; - const noticeStack = composerOverlayElement?.querySelector( - '[data-composer-banner-stack="true"]', - ); - const expandedNoticesHeight = noticeStack - ? Math.max( - 0, - noticeStack.getBoundingClientRect().height - - Number.parseFloat(getComputedStyle(noticeStack).minHeight), - ) - : 0; const nextInset = resolveComposerTimelineInset({ currentInset: composerTimelineInsetRef.current, overlayHeight: height, isResting, restingOnlyHeight, - expandedNoticesHeight, }); if (composerTimelineInsetRef.current !== nextInset) { composerTimelineInsetRef.current = nextInset; @@ -2226,9 +2197,8 @@ export default function ChatView(props: ChatViewProps) { const mainSurface = composerOverlayElement?.querySelector( '[data-chat-composer-main-surface="true"]', ); - const button = composerOverlayElement?.parentElement?.querySelector( - 'button[aria-label="Scroll to end"]', - ); + const button = + composerOverlayElement?.parentElement?.querySelector("[data-scroll-to-end]"); const clearance = composerOverlayElement && mainSurface && button ? resolveScrollToEndClearance({ @@ -2383,9 +2353,9 @@ export default function ChatView(props: ChatViewProps) { const { acknowledgeActiveThreadWoke, activeBranchMismatchKey, - backgroundWorkBanner, - childInputBanner, - goalBanner, + backgroundWorkNow, + childInputNow, + goalNow, handleSwitchCheckoutToThread, handleSwitchCheckoutToThreadStable, isRestoringThreadBranch, @@ -2550,9 +2520,6 @@ export default function ChatView(props: ChatViewProps) { : null; const composerBannerItems = (() => { const limitRecoveryItems = limitRecoveryBanner === null ? [] : [limitRecoveryBanner]; - const backgroundWorkItems = [childInputBanner, goalBanner, backgroundWorkBanner].filter( - (item) => item !== null, - ); const usageLimitsItems = usageLimitsBanner === null ? [] : [usageLimitsBanner]; const projectCloneItems = projectCloneBannerItem === null ? [] : [projectCloneBannerItem]; if (!localCheckoutBranchMismatch || !showBranchMismatchBanner || !activeBranchMismatchKey) { @@ -2562,7 +2529,6 @@ export default function ChatView(props: ChatViewProps) { ...usageLimitsItems, ...projectCloneItems, ...systemComposerBannerItems, - ...backgroundWorkItems, ]; } return [ @@ -2571,7 +2537,6 @@ export default function ChatView(props: ChatViewProps) { ...usageLimitsItems, ...projectCloneItems, ...systemComposerBannerItems, - ...backgroundWorkItems, branchMismatchBannerItem({ mismatchKey: activeBranchMismatchKey, mismatch: localCheckoutBranchMismatch, @@ -2979,6 +2944,66 @@ export default function ChatView(props: ChatViewProps) { openExpandedImagePreview(routeThreadKey, preview); }; const onExpandTimelineImageStable = useStableCallback(onExpandTimelineImage); + const shownThreadSyncPhase = activeEnvironmentUnavailable ? null : delayedThreadSyncPhase; + const hasThreadNow = + childInputNow !== null || + backgroundWorkNow !== null || + goalNow !== null || + shownThreadSyncPhase !== null; + const queuedRunCount = serverProjection ? getUserQueuedThreadRuns(serverProjection).length : 0; + // The queue control is mounted for every server thread but joins the footer only while it shows + // something, by its own rule: an optimistic message stops counting once the server has it. + const hasQueuedTurns = + queuedRunCount > 0 || + optimisticUserMessages.some( + (message) => + message.inputIntent === "queued_turn" && + !serverProjection?.messages.some((committed) => committed.id === message.id), + ); + const scrollToEndSummary = + [ + childInputNow === null ? null : "Subagent waiting", + queuedRunCount === 0 ? null : `${queuedRunCount} queued`, + ] + .filter((part) => part !== null) + .join(" · ") || null; + // The end of the timeline holds the thread's present and next turns: what it is doing now, + // its lifecycle status, guest messages awaiting you, then your queued messages. + const timelineFooter = + pendingHandoff === null && + !hasThreadNow && + threadStatusLine === null && + pendingGuestMessageCount === 0 && + !hasQueuedTurns ? null : ( + <> + {pendingHandoff === null ? null : ( +
+ +
+ )} + + {threadStatusLine} + {pendingGuestMessageCount > 0 && isServerThread && activeThread ? ( + + ) : null} + {hasQueuedTurns ? queuedRunsControl : null} + + ); const pendingSidebarFileDrops = useSidebarPendingFileDropStore((state) => state.pending); const consumePendingFileDrop = useSidebarPendingFileDropStore( @@ -3265,33 +3290,7 @@ export default function ChatView(props: ChatViewProps) { : {})} {...(onOpenWorktreeSetupTerminal ? { onOpenWorktreeSetupTerminal } : {})} isPreparingWorktree={!paintOnlyDisplayedTimeline && isPreparingWorktree} - footer={ - paintOnlyDisplayedTimeline || - (pendingHandoff === null && - pendingGuestMessageCount === 0 && - threadStatusLine === null) ? null : ( - <> - {pendingHandoff === null ? null : ( -
- -
- )} - {pendingGuestMessageCount > 0 && isServerThread && activeThread ? ( - - ) : null} - {threadStatusLine} - - ) - } + footer={paintOnlyDisplayedTimeline ? null : timelineFooter} listRef={legendListRef} runs={paintOnlyDisplayedTimeline ? [] : (serverProjection?.runs ?? [])} latestRun={paintOnlyDisplayedTimeline ? null : activeActivityRun} @@ -3367,6 +3366,7 @@ export default function ChatView(props: ChatViewProps) { onContentOverflowChange={setTimelineOverflows} onToolOutputCollapsedAtEnd={onToolOutputCollapsedAtEndStable} onViewportAttach={attachTimelineViewport} + onFooterGrow={onTimelineFooterGrowStable} hideEmptyPlaceholder={isDraftHeroState || threadDetailLoading} emptyPlaceholderInset={composerReservedHeight} topFadeEnabled={!hasTimelineTopBanner} @@ -3378,6 +3378,7 @@ export default function ChatView(props: ChatViewProps) { {showScrollToBottom && !isThreadFindActive && ( { composerRef.current?.restoreAfterTimelineReachedEnd(); scrollToEnd(true); @@ -3521,7 +3522,6 @@ export default function ChatView(props: ChatViewProps) { : projectCloneSendBlockReason } isPreparingWorktree={isPreparingWorktree && !sendQueuesBehindSetup} - queuedRunsControl={queuedRunsControl} bannerItems={composerBannerItems} resumeCompactionTokens={resumeCompactionTokens} keepFullHistory={keepFullHistory} @@ -3559,8 +3559,6 @@ export default function ChatView(props: ChatViewProps) { activeThreadModelSelection={activeThread?.modelSelection} activeProjectId={activeProject?.id ?? null} activeContextWindow={activeContextWindow} - activeTasksProgress={activeComposerTasksProgress} - activeTaskSteps={activeComposerTaskSteps} compactThreadUnavailable={compactThreadUnavailable} compactDisabled={compactDisabled} compactDisabledReason={compactDisabledReason} diff --git a/apps/web/src/components/chat/ChatComposer.tsx b/apps/web/src/components/chat/ChatComposer.tsx index caae00048fc9e..d7b46eea0abc0 100644 --- a/apps/web/src/components/chat/ChatComposer.tsx +++ b/apps/web/src/components/chat/ChatComposer.tsx @@ -48,7 +48,6 @@ import { createModelSelection, normalizeModelSlug } from "@t3tools/shared/model" import { USAGE_LIMITS_COMMAND } from "@t3tools/shared/usageLimits"; import { memo, - type ReactNode, useEffect, useEffectEvent, useId, @@ -105,14 +104,6 @@ import { useComposerTriggerState } from "./useComposerTriggerState"; import { useComposerMenuItems } from "./useComposerMenuItems"; import { useComposerFocusState } from "./useComposerFocusState"; import { useComposerMultilinePrompt } from "./useComposerMultilinePrompt"; -import { - ComposerTasksBadge, - ComposerTasksContent, - ComposerTasksDrawer, - type ComposerTaskStep, - type ComposerTasksProgress, -} from "./ComposerTasksBadge"; -import { ComposerActivityRow } from "./ComposerActivityStatus"; import { reconcileAttachmentContextReferences, useRetainedContextPayloads, @@ -120,11 +111,7 @@ import { import type { ThreadSyncPhase } from "../../threadSync"; import { ComposerBanner } from "./ComposerBanner"; import { ComposerSurface } from "./ComposerSurface"; -import { - ComposerBannerStack, - type ComposerBannerStackContent, - type ComposerBannerStackItem, -} from "./ComposerBannerStack"; +import { ComposerBannerStack, type ComposerBannerStackItem } from "./ComposerBannerStack"; import { attachmentsToReleaseOnUploadCapabilityLoss, composerOtherFilesForPresentation, @@ -274,7 +261,6 @@ import { resolveProviderSkillsForCwd, resolveProviderSlashCommandsForCwd, } from "@t3tools/client-runtime/providerSkills"; -import { useDelayedStatus } from "../../hooks/useDelayedStatus"; import { useMediaQuery } from "../../hooks/useMediaQuery"; import { useSoftwareKeyboardOpen } from "../../hooks/useSoftwareKeyboardOpen"; import { useStableCallback } from "../../hooks/useStableCallback"; @@ -435,8 +421,6 @@ export interface ChatComposerProps { showPlanFollowUpPrompt: boolean; activeProposedPlan: LatestProposedPlanState | null; - activeTasksProgress: ComposerTasksProgress | null; - activeTaskSteps: readonly ComposerTaskStep[] | null; threadSyncPhase: ThreadSyncPhase | null; runtimeMode: RuntimeMode; @@ -481,7 +465,6 @@ export interface ChatComposerProps { onPageScrollKeyUp: (key: string) => void; onPageScrollRelease: () => void; - queuedRunsControl?: ReactNode; editingQueuedAttachments: ReadonlyArray<{ readonly attachment: ContractChatAttachment; readonly url: string | null; @@ -663,9 +646,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) const activePendingProgress = holdingUserInput ? null : incomingPendingProgress; const activePendingIsResponding = !holdingUserInput && incomingPendingIsResponding; const isLiteralPendingAnswer = activePendingProgress?.activeQuestion?.initialAnswer !== undefined; - const shownSyncPhase = useDelayedStatus(composerDraftTargetKey, props.threadSyncPhase); - const activeTasksProgress = shownSyncPhase === null ? props.activeTasksProgress : null; - const activeTaskSteps = shownSyncPhase === null ? props.activeTaskSteps : null; const isEditingQueuedMessage = editingQueuedAttachments !== null; const composerDraft = useComposerThreadDraft(composerDraftTarget); const composerDraftTargetKeyRef = useRef(""); @@ -1097,7 +1077,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) const [composerMenuAnchor, setComposerMenuAnchor] = useState(null); const [hasWrappedPrompt, observeWrappedPrompt] = useComposerMultilinePrompt(); const hasMultilinePrompt = prompt.includes("\n") || hasWrappedPrompt; - const [isTasksDrawerOpen, setIsTasksDrawerOpen] = useState(false); // A pending question stays expanded: its card moves into the banner dock, // so collapsing would leave the surface empty and squashed beneath it. const isComposerCollapsedMobile = @@ -2309,28 +2288,8 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) importContextRecords, expandMobileComposer: expandMobileComposerStable, }); - const toggleTasksDrawer = () => { - setIsTasksDrawerOpen((open) => !open); - }; - const toggleTasksDrawerStable = useStableCallback(toggleTasksDrawer); - const hasBannerItems = props.bannerItems.length > 0; const hasBlockingComposerTopDrawer = activePendingApproval !== null || pendingUserInputs.length > 0; - const showInlineTasksBadge = - activeTasksProgress !== null && - activeTaskSteps !== null && - !isTasksDrawerOpen && - !hasBlockingComposerTopDrawer && - (hasBannerItems || showComposerTopDrawer || isComposerCollapsedMobile); - const inlineTasksBadge = showInlineTasksBadge ? ( - - ) : null; const hasImageAttachmentAttention = standaloneComposerImages.some((image) => { const upload = uploadsByImageId[image.id]; const failedInCurrentEnvironment = @@ -2341,7 +2300,6 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) }); const composerHasExpandedChrome = showComposerTopDrawer || - isTasksDrawerOpen || composerMenuOpen || isStashMenuOpen || isDragOverComposer || @@ -2421,8 +2379,7 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) canTrackComposerScrollGesture && settings.composerCollapseOnScroll && !hasMultilinePrompt && - !composerHasExpandedChrome && - !showInlineTasksBadge; + !composerHasExpandedChrome; const composerScrollCollapseEligible = canScrollCollapseComposer && !isComposerResting; useLayoutEffect(() => { composerScrollCollapseEligibleRef.current = composerScrollCollapseEligible; @@ -2586,48 +2543,14 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) getModelDisabledReason={getModelDisabledReason} /> ); - const showTasksTab = - !hasBannerItems && - !showComposerTopDrawer && - !isTasksDrawerOpen && - !isComposerCollapsedMobile && - activeTasksProgress !== null && - activeTaskSteps !== null && - activeTasksProgress.totalSteps > 0; - const activityStackContent = hasBannerItems ? ( - shownSyncPhase ? ( - - ) : !hasBlockingComposerTopDrawer && activeTasksProgress && activeTaskSteps ? ( - - ) : null - ) : null; - const activityStackItem: ComposerBannerStackContent | null = activityStackContent - ? { - id: "composer-activity", - variant: "default", - priority: "activity", - content: activityStackContent, - } - : null; - const bannerStackItems = activityStackItem - ? [activityStackItem, ...props.bannerItems] + // An open approval or question owns the space above the composer. Only a machine problem, + // which is why an answer could not go through, stays beside it. + const shelfItems = hasBlockingComposerTopDrawer + ? props.bannerItems.filter( + (item) => + item.group === "environment" && (item.variant === "error" || item.variant === "warning"), + ) : props.bannerItems; - const [tasksDrawerThreadId, setTasksDrawerThreadId] = useState(activeThreadId); - if ( - isTasksDrawerOpen && - (activeTasksProgress === null || - activeTaskSteps === null || - hasBlockingComposerTopDrawer || - tasksDrawerThreadId !== activeThreadId) - ) { - setIsTasksDrawerOpen(false); - } - if (tasksDrawerThreadId !== activeThreadId) setTasksDrawerThreadId(activeThreadId); const insertComposerText = ( text: string, @@ -3478,20 +3401,8 @@ export const ChatComposer = memo(function ChatComposer(props: ChatComposerProps) : null} - - {!activityStackItem && (shownSyncPhase || inlineTasksBadge) ? ( - - - {shownSyncPhase ? : inlineTasksBadge} - - - ) : null} - {showComposerTopDrawer && (!isTasksDrawerOpen || hasBlockingComposerTopDrawer) ? ( + + {showComposerTopDrawer ? ( ) : null} - {!activityStackItem && - isTasksDrawerOpen && - !hasBlockingComposerTopDrawer && - activeTasksProgress && - activeTaskSteps ? ( - - ) : null} - {showTasksTab ? ( - - - - ) : null} - - - - - - {threadSyncLabel(phase)} - - - - ); -} diff --git a/apps/web/src/components/chat/ComposerBanner.tsx b/apps/web/src/components/chat/ComposerBanner.tsx index be7e268ccb48d..ef07497171ee2 100644 --- a/apps/web/src/components/chat/ComposerBanner.tsx +++ b/apps/web/src/components/chat/ComposerBanner.tsx @@ -34,26 +34,22 @@ const variantColors: Record = { }; function Surface({ - placement = "attached", variant = "default", className, ...props }: ComponentProps<"div"> & { - placement?: "attached" | "floating"; variant?: ComposerBannerVariant; }) { return (
= { - default: "border-(--chat-composer-attached-outline)", - error: "border-destructive/24", - info: "border-(--chat-composer-attached-outline)", - success: "border-(--chat-composer-attached-outline)", - warning: "border-warning/24", -}; - -function Peek({ - className, - variant = "default", - ...props -}: ComponentProps<"button"> & { variant?: ComposerBannerVariant }) { - return ( - - ) : null} - - - {isEditing ? Editing queued message: : null} - {item.pending ? ( - - ) : null} - {item.thumbnails.length > 0 ? ( - - {item.thumbnails.map((thumbnail) => ( + {thumbnail.url ? ( + {thumbnail.name} + ) : ( - {thumbnail.url ? ( - {thumbnail.name} - ) : ( - - )} - - ))} + aria-label={thumbnail.name} + className="block size-full bg-muted/60" + /> + )} - ) : null} + ))} + + ) : null} + {/* In full, like a sent turn: a queued message is read before it is sent. */} + {previewText ? ( +

{item.guestName === undefined ? null : ( - {item.guestName} + {item.guestName} )} + {previewText} +

+ ) : null} +
+
+ {items.length > 1 && canReorder && rowRunId !== null && rowServerIndex !== null ? ( + + ) : items.length > 1 ? ( + {position + 1} + ) : null} + {item.pending ? ( + + + Saving + + ) : null} + {isEditing ? ( + <> + Editing in the composer + + + ) : ( + <> - }> - {previewText} + {/* The span keeps the tooltip, and its reason, on a disabled button. */} + }> + - - {previewText} + + {props.editBlockedReason ?? + `Edit in the composer${item.serverIndex === queued.length - 1 && props.editShortcutLabel ? ` (${props.editShortcutLabel})` : ""}`} - - - {isEditing ? ( - - ) : ( - <> - - {/* The span keeps the tooltip, and its reason, on a disabled button. */} - }> - - - - {props.editBlockedReason ?? - `Edit in the composer${item.serverIndex === queued.length - 1 && props.editShortcutLabel ? ` (${props.editShortcutLabel})` : ""}`} - - - - }> - - - - {`${workflow?.canSendNow ? "Start a turn with this message" : "Send as a steer instead"}${item.serverIndex === 0 && props.steerShortcutLabel ? ` (${props.steerShortcutLabel})` : ""}`} - - - - { - if (item.runId !== null) void remove(item.runId); - }} - /> + + }> + + + + {`${workflow?.canSendNow ? "Start a turn with this message" : "Send as a steer instead"}${item.serverIndex === 0 && props.steerShortcutLabel ? ` (${props.steerShortcutLabel})` : ""}`} + + + + { + if (item.runId !== null) void remove(item.runId); + }} /> - Remove from queue - - - )} - - - ); - })} - - - - + } + > + + + Remove from queue + + + )} +
+ + ); + })} + + {collapsible ? ( +
+ event.preventDefault()} + onClick={() => setShowAll((value) => !value)} + > + {showAll ? "Show fewer" : `Show all ${items.length} queued`} + + +
+ ) : null} + ); } diff --git a/apps/web/src/components/chat/ThreadActivityBanners.tsx b/apps/web/src/components/chat/ThreadActivityBanners.tsx index 39a60ed27ce3e..e132587a75951 100644 --- a/apps/web/src/components/chat/ThreadActivityBanners.tsx +++ b/apps/web/src/components/chat/ThreadActivityBanners.tsx @@ -15,21 +15,25 @@ import { cn } from "~/lib/utils"; import { Button, InlineButton } from "../ui/button"; import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip"; import type { ComposerBannerStackItem } from "./ComposerBannerStack"; +import type { ThreadNowItem } from "./ThreadNow"; /** Subagents waiting on the user, unless the parent is itself waiting on them. */ -export function childInputBannerItem(input: { +export function childInputNowItem(input: { readonly childThreadInputs: ReadonlyArray; readonly parentAwaitingUser: boolean; readonly onOpenThread: (threadId: ThreadId) => void; -}): ComposerBannerStackItem | null { +}): ThreadNowItem | null { const { childThreadInputs, onOpenThread } = input; const first = childThreadInputs[0]; if (!first || input.parentAwaitingUser) return null; return { id: `child-input:${first.id}`, - variant: "info", - priority: "activity", - icon: first.hasPendingApprovals ? : , + // The only line at the end of the timeline that needs you gets the info color. + icon: first.hasPendingApprovals ? ( + + ) : ( + + ), title: childThreadInputsTitle(childThreadInputs), description: childThreadInputs.map((child, index) => ( @@ -43,25 +47,24 @@ export function childInputBannerItem(input: { )), actions: ( - + ), }; } -export function goalBannerItem(input: { +/** The thread's goal, for the end of the timeline. */ +export function goalNowItem(input: { readonly threadId: ThreadId; readonly goal: OrchestrationV2ProviderGoal; readonly isWorking: boolean; readonly onSendCommand: (text: string, failureMessage: string) => Promise; -}): ComposerBannerStackItem { +}): ThreadNowItem { const { isWorking, onSendCommand } = input; const presentation = presentProviderGoal(input.goal, isWorking); return { id: `goal:${input.threadId}`, - variant: "default", - priority: "activity", icon: , title: presentation.usage === null @@ -72,46 +75,45 @@ export function goalBannerItem(input: { actions: ( <> {presentation.canResume && !isWorking ? ( - + <> + void onSendCommand("/goal resume", "Failed to resume goal.")} + > + Resume + + · + ) : null} - + ), }; } -export function backgroundWorkBannerItem(input: { +/** Background commands and subagents, for the end of the timeline. */ +export function backgroundWorkNowItem(input: { readonly threadId: ThreadId; readonly tasks: ReadonlyArray; readonly stopDisabled: boolean; readonly stopping: boolean; readonly onStop: () => Promise; readonly onOpenThread: (threadId: ThreadId) => void; -}): ComposerBannerStackItem | null { +}): ThreadNowItem | null { const { onOpenThread } = input; const presentation = presentPendingBackgroundWork(input.tasks); if (presentation === null) return null; return { id: `background-work:${input.threadId}`, - variant: "default", - priority: "activity", icon: (