import { NativeHeaderToolbar, NativeStackScreenOptions } from "../../native/StackHeader";import {  StackActions,  useFocusEffect,  useNavigation,  usePreventRemove,} from "@react-navigation/native";import { useCallback, useEffect, useRef, useState } from "react";import { Alert, Platform, Pressable, ScrollView, View } from "react-native";import {  KeyboardController,  KeyboardStickyView,  useKeyboardState,} from "react-native-keyboard-controller";import { useSafeAreaInsets } from "react-native-safe-area-context";import { useThemeColor } from "../../lib/useThemeColor";import { themeColorWithAlpha } from "../../lib/mobileTheme";import { useFontFamily } from "../../lib/useFontFamily"; import {  isAtomCommandInterrupted,  squashAtomCommandFailure,} from "@t3tools/client-runtime/state/runtime"; import { ComposerEditor, type ComposerEditorHandle } from "../../components/ComposerEditor";import {  ComposerInlineControl,  ComposerToolbarButton,  ComposerToolbarRow,  ComposerToolbarScroller,} from "../../components/ComposerToolbar";import { AndroidScreenHeader } from "../../components/AndroidScreenHeader";import { ComposerAttachmentStrip } from "../../components/ComposerAttachmentStrip";import { ProviderIcon } from "../../components/ProviderIcon";import { SymbolView } from "../../components/AppSymbol";import { AppText as Text } from "../../components/AppText";import { ComposerSurface } from "./ThreadComposer";import {  useThreadSettingsSheetPresentation,  type NavigationWithFinishTransitioning,} from "./use-thread-settings-sheet-presentation"; import { makeTurnCommandMetadata } from "../../lib/commandMetadata";import { convertPastedImagesToAttachments, pickComposerImages } from "../../lib/composerImages";import { useScaledTextRole } from "../settings/appearance/useScaledTextRole";import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider";import {  clearComposerDraftContent,  getComposerDraftSnapshot,  mergeComposerDraftContent,  restoreComposerDraftSnapshot,  type ComposerDraft,} from "../../state/use-composer-drafts";import { useEnvironmentServerConfig, useProjects } from "../../state/entities";import { resolveSelectableModelSelection } from "../../lib/modelOptions";import { deriveThreadTitleFromPrompt } from "../../lib/projectThreadStartTurn";import { armAgentAwarenessLiveActivityForLocalWork } from "../agent-awareness/remoteRegistration";import { enqueueThreadOutboxMessage, removeThreadOutboxMessage } from "../../state/thread-outbox";import { useRemoteConnectionStatus } from "../../state/use-remote-environment-registry";import { useNewTaskFlow } from "./new-task-flow-provider";import { resolveProjectThreadCreationBranch } from "./projectThreadCreationValidation";import { useCreateProjectThread } from "./use-project-actions";import { resolveDraftProjectSelection } from "./new-task-project-selection";import {  resolveNewTaskBranchLabel,  resolveNewTaskWorkspaceLabel,} from "./new-task-context-presentation";import { useIncomingShare } from "../sharing/IncomingShareProvider"; function NewTaskWorkspaceIcon(props: {  readonly workspaceMode: "local" | "worktree";  readonly worktreePath: string | null;}) {  const iconColor = useThemeColor("--color-icon-muted");   if (props.workspaceMode === "local" && props.worktreePath === null) {    return <SymbolView name="folder" size={16} tintColor={iconColor} type="monochrome" />;  }   return (    <View className="size-4">      <SymbolView name="folder" size={16} tintColor={iconColor} type="monochrome" />      <View className="absolute -right-1 -bottom-1">        <SymbolView name="arrow.triangle.branch" size={9} tintColor={iconColor} type="monochrome" />      </View>    </View>  );} export function NewTaskDraftScreen(props: {  readonly initialProjectRef?: {    readonly environmentId?: string;    readonly projectId?: string;  };  /** Queued outbox message id when editing an existing pending task. */  readonly pendingTaskId?: string;  /** Durable native share inbox item to merge into this project draft. */  readonly incomingShareId?: string;}) {  const projects = useProjects();  const createProjectThread = useCreateProjectThread();  const flow = useNewTaskFlow();  const navigation = useNavigation();  const {    consumeShare,    getShare,    isLoading: isIncomingShareInboxLoading,    releaseShareReservation,    reserveShare,  } = useIncomingShare();  const insets = useSafeAreaInsets();  const { themeAppearance: colorScheme } = useAppearancePreferences();  const isKeyboardVisible = useKeyboardState((state) => state.isVisible);  const controlsBottomPadding = Math.max(insets.bottom, 10);  const keyboardOpenedOffset = Math.max(0, controlsBottomPadding - 8);  const { projectScopes, selectedProject, selectedProjectKey, setProject } = flow;  const { connectedEnvironments } = useRemoteConnectionStatus();  const selectedEnvironmentServerConfig = useEnvironmentServerConfig(    selectedProject?.environmentId ?? null,  );  const environmentConnected =    selectedProject !== null &&    connectedEnvironments.find(      (environment) => environment.environmentId === selectedProject.environmentId,    )?.connectionState === "connected";  const promptInputRef = useRef<ComposerEditorHandle>(null);  const loadedBranchesProjectKeyRef = useRef<string | null>(null);  const [isComposerFocused, setIsComposerFocused] = useState(false);  const settingsSheetPresentation = useThreadSettingsSheetPresentation({    editorRef: promptInputRef,    isEditorFocused: isComposerFocused,  });  useEffect(() => {    if (Platform.OS !== "ios") {      return;    }     navigation.getParent()?.setOptions({ gestureEnabled: !isKeyboardVisible });  }, [isKeyboardVisible, navigation]);  useEffect(() => {    return () => {      if (Platform.OS === "ios") {        navigation.getParent()?.setOptions({ gestureEnabled: true });      }    };  }, [navigation]);  const settingsRoutePresentedRef = useRef(false);  useEffect(() => {    if (!settingsSheetPresentation.isVisible || settingsRoutePresentedRef.current) {      return;    }     settingsRoutePresentedRef.current = true;    navigation.dispatch(StackActions.push("ThreadSettings"));  }, [navigation, settingsSheetPresentation.isVisible]);  useFocusEffect(    useCallback(() => {      if (!settingsRoutePresentedRef.current) {        return;      }       settingsRoutePresentedRef.current = false;      settingsSheetPresentation.onDismissed();    }, [settingsSheetPresentation.onDismissed]),  );  useEffect(    () =>      // UIKit's completion callback for the sheet dismissal, surfaced by the      // native-stack patch. This is when the queued keyboard restore runs.      (navigation as unknown as NavigationWithFinishTransitioning).addListener(        "finishTransitioning",        settingsSheetPresentation.onStackTransitionsFinished,      ),    [navigation, settingsSheetPresentation.onStackTransitionsFinished],  );  const [importingShareKey, setImportingShareKey] = useState<string | null>(null);  const [isCancellingShareImport, setIsCancellingShareImport] = useState(false);  const [cancelledIncomingShareId, setCancelledIncomingShareId] = useState<string | null>(null);  const [isReturningToProjectPicker, setIsReturningToProjectPicker] = useState(false);  const [shareImportAttempt, setShareImportAttempt] = useState(0);  const startedShareImportKeyRef = useRef<string | null>(null);  const cancellingShareImportKeyRef = useRef<string | null>(null);  const shareImportDraftBackupRef = useRef(new Map<string, ComposerDraft>());  const activeShareImportTokenRef = useRef<symbol | null>(null);  const shareImportMountedRef = useRef(true);  const latestDraftKeyRef = useRef(flow.draftKey);  const latestIncomingShareIdRef = useRef(props.incomingShareId);  latestDraftKeyRef.current = flow.draftKey;  latestIncomingShareIdRef.current = props.incomingShareId;  const isImportingShare = importingShareKey !== null;  const alertedUnavailableIncomingShareIdRef = useRef<string | null>(null);  const incomingShare = props.incomingShareId ? getShare(props.incomingShareId) : null;  const requestedInitialProjectAvailable = Boolean(    props.initialProjectRef?.environmentId &&    props.initialProjectRef.projectId &&    projects.some(      (project) =>        project.environmentId === props.initialProjectRef?.environmentId &&        project.id === props.initialProjectRef?.projectId,    ),  );  const isProjectPickerReturnActive =    isReturningToProjectPicker && !requestedInitialProjectAvailable;  const isIncomingShareTransferPending = Boolean(    incomingShare && cancelledIncomingShareId !== props.incomingShareId,  );  usePreventRemove(    (isIncomingShareTransferPending && !isProjectPickerReturnActive) || isCancellingShareImport,    () => undefined,  );  const hasImportedIncomingShare = Boolean(    props.incomingShareId &&    flow.draftKey &&    getComposerDraftSnapshot(flow.draftKey).importedShareIds?.includes(props.incomingShareId),  );  const isIncomingShareUnavailable = Boolean(    props.incomingShareId &&    !isIncomingShareInboxLoading &&    !incomingShare &&    !hasImportedIncomingShare,  );  const isIncomingShareReady =    !props.incomingShareId ||    (hasImportedIncomingShare && !incomingShare) ||    isIncomingShareUnavailable;  const appliedInitialProjectKeyRef = useRef<string | null>(null);  useEffect(() => {    if (cancelledIncomingShareId === props.incomingShareId) {      navigation.goBack();    }  }, [cancelledIncomingShareId, navigation, props.incomingShareId]);  useEffect(() => {    if (!isReturningToProjectPicker) {      return;    }    if (requestedInitialProjectAvailable) {      setIsReturningToProjectPicker(false);      return;    }    // Let usePreventRemove commit its disabled state before replacing this    // route, otherwise the transfer guard can swallow the fallback action.    const frame = requestAnimationFrame(() => {      navigation.dispatch(        StackActions.replace("NewTask", { incomingShareId: props.incomingShareId }),      );    });    return () => cancelAnimationFrame(frame);  }, [    isReturningToProjectPicker,    navigation,    props.incomingShareId,    requestedInitialProjectAvailable,  ]);  useEffect(() => {    if (!shareImportMountedRef.current) {      startedShareImportKeyRef.current = null;    }    shareImportMountedRef.current = true;    return () => {      appliedInitialProjectKeyRef.current = null;      shareImportMountedRef.current = false;      activeShareImportTokenRef.current = null;      cancellingShareImportKeyRef.current = null;    };  }, []);   const { beginEditingPendingTask, cancelEditingPendingTask, editingPendingTask } = flow;  const attemptedPendingTaskIdRef = useRef<string | null>(null);  useEffect(() => {    if (!props.pendingTaskId || editingPendingTask?.messageId === props.pendingTaskId) {      return;    }    // Attempt each pending task once: after it is delivered or deleted the    // editing session legitimately ends, and re-running must not navigate.    if (attemptedPendingTaskIdRef.current === props.pendingTaskId) {      return;    }    attemptedPendingTaskIdRef.current = props.pendingTaskId;    if (!beginEditingPendingTask(props.pendingTaskId)) {      // The queued task no longer exists (sent or deleted before opening).      navigation.dispatch(StackActions.replace("NewTask"));    }  }, [beginEditingPendingTask, editingPendingTask?.messageId, navigation, props.pendingTaskId]);   useEffect(() => {    if (!props.pendingTaskId) return;    return () => {      // Allow a later navigation for the same pending task to re-hydrate it.      attemptedPendingTaskIdRef.current = null;      cancelEditingPendingTask();    };  }, [props.pendingTaskId, cancelEditingPendingTask]);   const foregroundColor = useThemeColor("--color-foreground");  const sheetColor = String(useThemeColor("--color-sheet"));  const projectUnderlineColor = useThemeColor("--color-foreground-muted");  const regularFontFamily = useFontFamily("regular");  const bodyText = useScaledTextRole("body");  const sheetFadeOpaque = sheetColor;  const sheetFadeTransparent = themeColorWithAlpha(sheetColor, 0);   // A new navigation to this mounted screen delivers a fresh initialProjectRef  // reference — treat it as a new request and let it apply again.  const lastInitialProjectRefRef = useRef(props.initialProjectRef);   useEffect(() => {    // Pending-task editing owns project selection (and must not fall through    // to the replace("NewTask") fallback while its hydration is in flight).    if (props.pendingTaskId) {      return;    }    if (lastInitialProjectRefRef.current !== props.initialProjectRef) {      lastInitialProjectRefRef.current = props.initialProjectRef;      appliedInitialProjectKeyRef.current = null;    }    const initialEnvironmentId = props.initialProjectRef?.environmentId;    const initialProjectId = props.initialProjectRef?.projectId;    if (initialEnvironmentId && initialProjectId) {      const directProject =        projects.find(          (project) =>            project.environmentId === initialEnvironmentId && project.id === initialProjectId,        ) ?? null;       if (directProject) {        // Apply the route's project once. Re-applying on every change would        // instantly revert environment/project switches made in the picker.        const directProjectKey = `${directProject.environmentId}:${directProject.id}`;        if (appliedInitialProjectKeyRef.current === directProjectKey) {          return;        }        appliedInitialProjectKeyRef.current = directProjectKey;        if (          selectedProject?.environmentId === directProject.environmentId &&          selectedProject.id === directProject.id        ) {          return;        }        setProject(directProject);        return;      }       if (projects.length > 0) {        // Never fall through to the flow provider's temporary first-project        // default. Return to the picker with the share id intact so the user        // can choose an available destination.        setIsReturningToProjectPicker(true);      }      return;    }     const selection = resolveDraftProjectSelection(selectedProjectKey, projects, projectScopes);    if (selection.kind === "preserve") {      return;    }    if (selection.kind === "select") {      setProject(selection.project);      return;    }     navigation.dispatch(StackActions.replace("NewTask"));  }, [    projectScopes,    projects,    props.initialProjectRef,    props.incomingShareId,    props.pendingTaskId,    navigation,    selectedProject,    selectedProjectKey,    setProject,  ]);   useEffect(() => {    if (!selectedProject) {      loadedBranchesProjectKeyRef.current = null;      return;    }    const projectKey = `${selectedProject.environmentId}:${selectedProject.id}`;    if (loadedBranchesProjectKeyRef.current === projectKey) {      return;    }    loadedBranchesProjectKeyRef.current = projectKey;    flow.loadBranches();  }, [flow.loadBranches, selectedProject]);   useEffect(() => {    const shareId = props.incomingShareId;    const draftKey = flow.draftKey;    const destinationProject = selectedProject;    const initialEnvironmentId = props.initialProjectRef?.environmentId;    const initialProjectId = props.initialProjectRef?.projectId;    const selectedProjectMatchesRoute =      !initialEnvironmentId ||      !initialProjectId ||      (destinationProject?.environmentId === initialEnvironmentId &&        destinationProject.id === initialProjectId);    if (      !shareId ||      !draftKey ||      !destinationProject ||      !selectedProjectMatchesRoute ||      cancelledIncomingShareId === shareId    ) {      return;    }    const importKey = `${shareId}:${draftKey}`;    if (      startedShareImportKeyRef.current === importKey ||      cancellingShareImportKeyRef.current === importKey    ) {      return;    }     if (!incomingShare) {      if (isIncomingShareUnavailable && alertedUnavailableIncomingShareIdRef.current !== shareId) {        alertedUnavailableIncomingShareIdRef.current = shareId;        Alert.alert(          "Shared content unavailable",          "The shared content is no longer in the inbox. You can continue editing this task draft.",        );      }      return;    }     if (alertedUnavailableIncomingShareIdRef.current === shareId) {      alertedUnavailableIncomingShareIdRef.current = null;    }    startedShareImportKeyRef.current = importKey;    const draftBackup =      shareImportDraftBackupRef.current.get(importKey) ?? getComposerDraftSnapshot(draftKey);    shareImportDraftBackupRef.current.set(importKey, draftBackup);    const importToken = Symbol(importKey);    let didReserveShare = false;    let needsDraftRestore = false;    activeShareImportTokenRef.current = importToken;    setImportingShareKey(importKey);    void (async () => {      await reserveShare(shareId, {        environmentId: String(destinationProject.environmentId),        projectId: String(destinationProject.id),      });      didReserveShare = true;      if (        !shareImportMountedRef.current ||        activeShareImportTokenRef.current !== importToken ||        latestDraftKeyRef.current !== draftKey ||        latestIncomingShareIdRef.current !== shareId      ) {        return;      }      needsDraftRestore = true;      const { skippedAttachmentCount } = await mergeComposerDraftContent(draftKey, {        text: incomingShare.text,        attachments: incomingShare.attachments,        sourceShareId: shareId,      });      if (        !shareImportMountedRef.current ||        activeShareImportTokenRef.current !== importToken ||        latestDraftKeyRef.current !== draftKey ||        latestIncomingShareIdRef.current !== shareId      ) {        // The durable reservation makes an interrupted transfer resume only        // in this project instead of copying into a second project draft.        return;      }      await consumeShare(shareId);      if (!shareImportMountedRef.current || activeShareImportTokenRef.current !== importToken) {        return;      }      const warnings = [...incomingShare.warnings];      if (skippedAttachmentCount > 0) {        warnings.push(          `${skippedAttachmentCount} shared image${skippedAttachmentCount === 1 ? " was" : "s were"} skipped because this draft reached the attachment limit.`,        );      }      if (warnings.length > 0) {        Alert.alert("Some shared content was skipped", warnings.join("\n"));      }      shareImportDraftBackupRef.current.delete(importKey);    })()      .catch((error) => {        if (!shareImportMountedRef.current || activeShareImportTokenRef.current !== importToken) {          return;        }        Alert.alert(          "Could not import shared content",          error instanceof Error ? error.message : "The shared content could not be saved.",          [            {              text: "Cancel import",              style: "cancel",              onPress: () => {                const cancelImport = async (): Promise<void> => {                  if (!shareImportMountedRef.current) {                    return;                  }                  // Latch synchronously before restoring the draft. The                  // restore publishes atom state and can re-run the import

Lines 1–500 of 1087. Load more