diff --git a/apps/mobile/src/features/threads/NewTaskRouteScreen.test.tsx b/apps/mobile/src/features/threads/NewTaskRouteScreen.test.tsx new file mode 100644 index 0000000000000..20ac36d3f7ad8 --- /dev/null +++ b/apps/mobile/src/features/threads/NewTaskRouteScreen.test.tsx @@ -0,0 +1,224 @@ +import type { ReactNode } from "react"; +import { act } from "react"; +import * as React from "react"; +import { createRoot } from "react-dom/client"; +import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; +import { EnvironmentId, ProjectId } from "@t3tools/contracts"; +import { expect, it, vi } from "vite-plus/test"; +import { retargetSavedNewTaskDraft } from "../../state/use-composer-drafts"; + +const environmentId = EnvironmentId.make("env-1"); + +function project(id: string, workspaceRoot: string): EnvironmentProject { + return { + environmentId, + id: ProjectId.make(id), + title: id, + workspaceRoot, + repositoryIdentity: null, + defaultModelSelection: null, + defaultThreadEnvMode: "worktree", + scripts: [], + createdAt: "2026-10-26T00:00:00Z", + updatedAt: "2026-10-26T00:00:00Z", + }; +} + +const regular = project("app", "/repo/app"); +const scratch = project("scratch", "/scratch"); + +const harness = vi.hoisted(() => ({ + setProject: vi.fn(), + openScratch: vi.fn(), + selectDetail: vi.fn(), + navigation: { + goBack: vi.fn(), + getState: () => ({ + routeNames: ["Thread", "NewTaskProject"], + index: 1, + routes: [{ name: "Thread", params: { draft: {} } }, { name: "NewTaskProject" }], + }), + getParent: () => undefined, + canGoBack: () => true, + dispatch: vi.fn(), + navigate: vi.fn(), + }, +})); + +vi.mock("react-native", () => ({ + Platform: { OS: "ios" }, + View: ({ children }: { children?: ReactNode }) =>
{children}
, + Pressable: (props: { + accessibilityLabel: string; + disabled?: boolean; + onPress: () => void; + children?: ReactNode; + }) => ( + + ), +})); +vi.mock("react-native-safe-area-context", () => ({ + useSafeAreaInsets: () => ({ top: 0, bottom: 0, left: 0, right: 0 }), +})); +vi.mock("gt-react-native", () => ({ + msg: (text: string) => text, + T: ({ children }: { children?: ReactNode }) => <>{children}, + useGT: () => (text: string) => text, + useMessages: () => (text: string) => text, +})); +vi.mock("@react-navigation/native", () => ({ + StackActions: { push: (name: string) => ({ type: "PUSH", name }) }, + useFocusEffect: (effect: () => () => void) => React.useEffect(effect, [effect]), + useIsFocused: () => true, + useNavigation: () => harness.navigation, +})); +vi.mock("../../components/ui/NavigationRow", () => ({ + NavigationRow: (props: { title: string; disabled?: boolean; onPress?: () => void }) => ( + + ), +})); +vi.mock("../../components/ui/Dialog", () => ({ alert: vi.fn() })); +vi.mock("../../components/ui/AppActivityIndicator", () => ({ AppActivityIndicator: () => null })); +vi.mock("../../components/ui/AppBar", () => ({ AppBar: () => null })); +vi.mock("../../components/ui/AppSymbol", () => ({ SymbolView: () => null })); +vi.mock("../../components/ui/Button", () => ({ Button: () => null })); +vi.mock("../../components/ui/ScreenContent", () => ({ + ScreenContent: ({ children }: { children?: ReactNode }) => <>{children}, +})); +vi.mock("../../components/ui/ScreenScrollView", () => ({ + ScreenScrollView: ({ children }: { children?: ReactNode }) => <>{children}, +})); +vi.mock("../../components/ui/AppText", () => ({ + AppText: ({ children }: { children?: ReactNode }) => {children}, +})); +vi.mock("../../components/ProjectFavicon", () => ({ ProjectFavicon: () => null })); +vi.mock("../connection/environmentStatusText", () => ({ runtimeConnectionErrorText: () => null })); +vi.mock("../../state/entities", () => ({ + useProjects: () => [regular, scratch], + useServerConfigs: () => new Map([[environmentId, { scratchWorkspaceRoot: "/scratch" }]]), +})); +vi.mock("../../state/projects", () => ({ projectEnvironment: { openScratch: {} } })); +vi.mock("../../state/use-atom-command", () => ({ useAtomCommand: () => harness.openScratch })); +vi.mock("../../state/use-composer-drafts", () => ({ retargetSavedNewTaskDraft: vi.fn() })); +vi.mock("../../state/use-remote-environment-registry", () => ({ + useRemoteConnectionStatus: () => ({ + connectedEnvironments: [{ environmentId, connectionState: "connected" }], + }), +})); +vi.mock("../../state/workspace", () => ({ + useWorkspaceState: () => ({ state: { hasReadyEnvironment: true } }), +})); +vi.mock("../sharing/IncomingShareProvider", () => ({ + useIncomingShare: () => ({ getShare: () => null, releaseShareReservation: vi.fn() }), +})); +vi.mock("../layout/workspace/useSelectWorkspaceDetail", () => ({ + useSelectWorkspaceDetail: () => harness.selectDetail, +})); +vi.mock("./new-task-flow-provider", () => ({ + useNewTaskFlow: () => ({ + projectScopes: [ + { + key: "app", + title: "app", + representative: regular, + projects: [regular], + projectRefs: [], + pinned: false, + archived: false, + }, + ], + selectedEnvironmentId: environmentId, + setProject: harness.setProject, + }), +})); + +import { NewTaskRouteScreen } from "./NewTaskRouteScreen"; + +it("keeps the project picked while No project was still opening", async () => { + (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true; + const opening = Promise.withResolvers(); + harness.openScratch.mockReturnValue(opening.promise); + + const container = document.createElement("div"); + const root = createRoot(container); + using _root = { [Symbol.dispose]: () => act(() => root.unmount()) }; + act(() => root.render()); + const row = (label: string) => container.querySelector(`[aria-label="${label}"]`)!; + + act(() => row("No project").click()); + await act(async () => row("app").click()); + await act(async () => opening.resolve({ _tag: "Success", value: scratch })); + + expect(harness.setProject.mock.calls).toEqual([[regular]]); + expect(harness.navigation.goBack).toHaveBeenCalledTimes(1); +}); + +function renderWithSavedDraft() { + (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true; + const opening = Promise.withResolvers(); + const retargeting = Promise.withResolvers(); + harness.openScratch.mockReturnValue(opening.promise); + vi.mocked(retargetSavedNewTaskDraft) + .mockReset() + .mockImplementation((_draftId, target) => + target.projectId === scratch.id ? retargeting.promise : Promise.resolve(true), + ); + harness.selectDetail.mockClear(); + + const container = document.createElement("div"); + const root = createRoot(container); + const route = { params: { draftId: "existing-draft" } } as never; + act(() => root.render()); + return { + opening, + retargeting, + root, + route, + row: (label: string) => container.querySelector(`[aria-label="${label}"]`)!, + [Symbol.dispose]: () => act(() => root.unmount()), + }; +} + +const appDraftSelection = [ + [ + { + name: "Thread", + params: { draft: { environmentId, projectId: regular.id, draftId: "existing-draft" } }, + }, + ], +]; + +it("keeps the picked project after backing out and reopening while No project is pending", async () => { + using screen = renderWithSavedDraft(); + + act(() => screen.row("No project").click()); + act(() => screen.root.render(null)); + act(() => screen.root.render()); + await act(async () => screen.row("app").click()); + await act(async () => { + screen.opening.resolve({ _tag: "Success", value: scratch }); + screen.retargeting.resolve(true); + }); + + expect(harness.selectDetail.mock.calls).toEqual(appDraftSelection); +}); + +it("cancels the No project draft retarget when another project is picked", async () => { + using screen = renderWithSavedDraft(); + + act(() => screen.row("No project").click()); + await act(async () => screen.opening.resolve({ _tag: "Success", value: scratch })); + const scratchSignal = vi + .mocked(retargetSavedNewTaskDraft) + .mock.calls.find(([, target]) => target.projectId === scratch.id)?.[2]; + expect(scratchSignal?.aborted).toBe(false); + await act(async () => screen.row("app").click()); + expect(scratchSignal?.aborted).toBe(true); + await act(async () => screen.retargeting.resolve(true)); + + expect(harness.selectDetail.mock.calls).toEqual(appDraftSelection); +}); diff --git a/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx b/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx index f429972a176fc..716713e4293d2 100644 --- a/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx +++ b/apps/mobile/src/features/threads/NewTaskRouteScreen.tsx @@ -7,6 +7,7 @@ import { NavigationRow } from "../../components/ui/NavigationRow"; import { AppBar } from "../../components/ui/AppBar"; import { StackActions, + useFocusEffect, useIsFocused, useNavigation, type StaticScreenProps, @@ -19,7 +20,7 @@ import { squashAtomCommandFailure, } from "@t3tools/client-runtime/state/runtime"; import type { EnvironmentProject } from "@t3tools/client-runtime/state/shell"; -import { useEffect, useRef, useState } from "react"; +import { useCallback, useEffect, useRef, useState } from "react"; import { Platform, Pressable, View } from "react-native"; import { useSafeAreaInsets } from "react-native-safe-area-context"; import { cn } from "../../lib/cn"; @@ -235,13 +236,19 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps(null); + const cancelPendingScratch = useCallback(() => { + pendingScratchRef.current?.abort(); + pendingScratchRef.current = null; + }, []); + useFocusEffect(useCallback(() => cancelPendingScratch, [cancelPendingScratch])); - async function selectProject(project: EnvironmentProject): Promise { + async function selectProject(project: EnvironmentProject, signal?: AbortSignal): Promise { if (incomingShare?.destination && !reservedDestinationProject) { try { await releaseShareReservation(incomingShare.id, incomingShare.destination); } catch (error) { + if (signal?.aborted) return; Dialog.alert( gt("Could not change project"), errorDisplayMessage(error, m) ?? @@ -249,6 +256,7 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps found, () => null, ); + if (signal?.aborted) return; if (retargeted === null) { Dialog.alert( gt("Could not change project"), @@ -292,13 +302,20 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps { - if (!canStartScratch || !scratchOption || scratchStartInFlightRef.current) return; + if (!canStartScratch || !scratchOption || pendingScratchRef.current) return; const environmentId = scratchOption.environmentId; - scratchStartInFlightRef.current = true; + const request = new AbortController(); + pendingScratchRef.current = request; const result = await openScratch({ environmentId, input: {} }); + if (request.signal.aborted) return; if (result._tag === "Failure") { - scratchStartInFlightRef.current = false; + pendingScratchRef.current = null; if (!isAtomCommandInterrupted(result)) { const error = squashAtomCommandFailure(result); Dialog.alert( @@ -309,9 +326,8 @@ export function NewTaskRouteScreen({ route }: StaticScreenProps void selectProject(selectionTarget)} + onPress={() => chooseProject(selectionTarget)} leading={ void selectProject(selectionTarget)} + onPress={() => chooseProject(selectionTarget)} className="flex-row items-center gap-3 bg-grouped-card px-4 py-3.5" > diff --git a/apps/mobile/src/state/use-composer-drafts.test.ts b/apps/mobile/src/state/use-composer-drafts.test.ts index 0f0e4a69419fb..6345836750a3f 100644 --- a/apps/mobile/src/state/use-composer-drafts.test.ts +++ b/apps/mobile/src/state/use-composer-drafts.test.ts @@ -2053,6 +2053,14 @@ describe("mobile composer drafts", () => { appAtomRegistry.set(composerDraftsAtom, {}); resetComposerDraftsLoadState(); + composerDraftFileMocks.blockRead(); + const controller = new AbortController(); + const cancelled = retargetSavedNewTaskDraft(key, to, controller.signal); + controller.abort(); + composerDraftFileMocks.releaseRead(); + await expect(cancelled).resolves.toBe(false); + expect(getComposerDraftSnapshot(key).project).toMatchObject(from); + await expect(retargetSavedNewTaskDraft(key, to)).resolves.toBe(true); expect(getComposerDraftSnapshot(key)).toMatchObject({ text: "kept through a cold start", diff --git a/apps/mobile/src/state/use-composer-drafts.ts b/apps/mobile/src/state/use-composer-drafts.ts index 57b620de5264b..f5c47c24847bb 100644 --- a/apps/mobile/src/state/use-composer-drafts.ts +++ b/apps/mobile/src/state/use-composer-drafts.ts @@ -2075,13 +2075,15 @@ export function retargetNewTaskDraft( }); } -/** Retargets a saved draft once drafts load; an absent one is not created. */ +/** Retargets a saved draft after loading. Returns false if absent or cancelled before the write. */ export async function retargetSavedNewTaskDraft( draftKey: string, project: { readonly environmentId: EnvironmentId; readonly projectId: ProjectId }, + signal?: AbortSignal, ): Promise { await waitForComposerDraftsLoaded(); - if (appAtomRegistry.get(composerDraftsAtom)[draftKey] === undefined) return false; + if (signal?.aborted || appAtomRegistry.get(composerDraftsAtom)[draftKey] === undefined) + return false; retargetNewTaskDraft(draftKey, project); return true; } diff --git a/apps/mobile/vite.config.ts b/apps/mobile/vite.config.ts index 05261f9cb1848..80fca082c7c8e 100644 --- a/apps/mobile/vite.config.ts +++ b/apps/mobile/vite.config.ts @@ -8,6 +8,7 @@ const reactTests = [ "src/features/threads/useSubmitAfterNativeImages.test.tsx", "src/features/threads/git/GitBranchesSheet.test.tsx", "src/features/threads/new-task-flow-provider.test.tsx", + "src/features/threads/NewTaskRouteScreen.test.tsx", "src/features/layout/workspace/workspace-tabs-state.test.ts", "src/state/use-thread-pr.demand.test.tsx", "src/features/threads/git/GitBranchesSheet.occupancy.test.tsx",