feat(git): choose which remote a branch pushes to

apps/mobile/src/Stack.tsx

@@ -57,6 +57,7 @@ import { ThreadTerminalRouteScreen } from "./features/terminal/ThreadTerminalRou
 import { DevicePreviewRouteScreen } from "./features/devices/DevicePreviewRouteScreen";
 import { BrowserPreviewRouteScreen } from "./features/browser/BrowserPreviewRouteScreen";
 import { GitBranchesSheet } from "./features/threads/git/GitBranchesSheet";
+import { GitRemoteSheet } from "./features/threads/git/GitRemoteSheet";
 import { GitCommitSheet } from "./features/threads/git/GitCommitSheet";
 import { GitConfirmSheet } from "./features/threads/git/GitConfirmSheet";
 import { GitOverviewSheet } from "./features/threads/git/GitOverviewSheet";
@@ -703,6 +704,11 @@ const RootStackConfig = createWorkspaceStackNavigator({
       linking: `${THREAD_LINKING_PREFIX}/git/branches`,
       options: sheetRoute({ detent: 0.55, androidFit: true }),
     }),
+    GitRemote: createNativeStackScreen({
+      screen: GitRemoteSheet,
+      linking: `${THREAD_LINKING_PREFIX}/git/remote`,
+      options: sheetRoute({ detent: 0.55, androidFit: true }),
+    }),
     GitConfirm: createNativeStackScreen({
       screen: GitConfirmSheet,
       linking: `${THREAD_LINKING_PREFIX}/git-confirm`,

apps/mobile/src/features/layout/workspace-overlay-routes.ts

@@ -11,6 +11,7 @@ const LISTED_OVERLAY_ROUTES: ReadonlySet<string> = new Set([
   "GitBranches",
   "GitCommit",
   "GitConfirm",
+  "GitRemote",
   "GitOverview",
   "NewTaskProject",
   "NewTaskFiles",

apps/mobile/src/features/threads/git/GitOverviewSheet.tsx

@@ -299,6 +299,22 @@ function GitOverviewSheetContent(props: GitOverviewSheetProps) {
             )
           }
         />
+        {gitStatus.data?.remotes && gitStatus.data.refName ? (
+          <ListRow
+            icon="cloud"
+            label="Push remote"
+            description={gitStatus.data.pushRemote ?? "Not chosen"}
+            disabled={busy}
+            onPress={() =>
+              presentRoute(() =>
+                navigation.navigate("GitRemote", {
+                  environmentId: String(environmentId),
+                  threadId: String(threadId),
+                }),
+              )
+            }
+          />
+        ) : null}
         {linkedPrActions.canLink ? (
           <ListRow
             icon="link"

apps/mobile/src/features/threads/git/GitRemoteSheet.tsx

@@ -0,0 +1,103 @@
+import type { GitStackedAction } from "@t3tools/contracts";
+import { StackActions, useNavigation, type StaticScreenProps } from "@react-navigation/native";
+import { Platform, ScrollView, useWindowDimensions, View } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { ListChoiceRow } from "../../../components/ui/ListChoiceRow";
+import { ListSection } from "../../../components/ui/ListSection";
+import { ScreenContent } from "../../../components/ui/ScreenContent";
+import { SheetHeader } from "../../../components/ui/SheetHeader";
+import { useEnvironmentQuery } from "../../../state/query";
+import { useSelectedThreadGitActions } from "../../../state/use-selected-thread-git-actions";
+import { useSelectedThreadWorktree } from "../../../state/use-selected-thread-worktree";
+import { useThreadSelection } from "../../../state/use-thread-selection";
+import { vcsEnvironment } from "../../../state/vcs";
+
+type GitRemoteSheetProps = StaticScreenProps<{
+  readonly environmentId: string;
+  readonly threadId: string;
+  /** Set when a git action is waiting on the choice; it runs once a remote is picked. */
+  readonly action?: GitStackedAction;
+  readonly commitMessage?: string;
+  readonly featureBranch?: string;
+  readonly filePaths?: string;
+}>;
+
+export function GitRemoteSheet(props: GitRemoteSheetProps) {
+  const { environmentId, threadId, action, commitMessage, featureBranch, filePaths } =
+    props.route.params;
+  const navigation = useNavigation();
+  const insets = useSafeAreaInsets();
+  const { height: windowHeight } = useWindowDimensions();
+  const { selectedThread } = useThreadSelection();
+  const { selectedThreadCwd } = useSelectedThreadWorktree();
+  const gitActions = useSelectedThreadGitActions();
+  const gitStatus = useEnvironmentQuery(
+    selectedThread !== null && selectedThreadCwd !== null
+      ? vcsEnvironment.status({
+          environmentId: selectedThread.environmentId,
+          input: { cwd: selectedThreadCwd },
+        })
+      : null,
+  );
+  const remotes = gitStatus.data?.remotes ?? [];
+  const pushRemote = gitStatus.data?.pushRemote;
+
+  const selectRemote = async (remoteName: string) => {
+    if (action) {
+      navigation.dispatch(StackActions.replace("Thread", { environmentId, threadId }));
+      await gitActions.onRunSelectedThreadGitAction({
+        action,
+        pushRemote: remoteName,
+        ...(commitMessage ? { commitMessage } : {}),
+        ...(featureBranch === "true" ? { featureBranch: true } : {}),
+        ...(filePaths ? { filePaths: JSON.parse(filePaths) as string[] } : {}),
+      });
+      return;
+    }
+    const result = await gitActions.onSetSelectedThreadPushRemote(remoteName);
+    if (result !== null) navigation.goBack();
+  };
+
+  return (
+    <View
+      collapsable={false}
+      className="bg-sheet ios:flex-1 android:flex-col-reverse"
+      style={Platform.OS === "android" ? { maxHeight: windowHeight * 0.92 } : undefined}
+    >
+      <ScreenContent fitToContents>
+        <ScrollView
+          nestedScrollEnabled
+          className="android:shrink android:grow-0 ios:flex-1"
+          contentInsetAdjustmentBehavior="automatic"
+          showsVerticalScrollIndicator={false}
+          contentInset={{ bottom: Math.max(insets.bottom, 18) + 18 }}
+          contentContainerClassName="android:gap-2 android:p-2 ios:gap-4 ios:px-5 ios:pt-2"
+        >
+          <ListSection
+            {...(action
+              ? {
+                  footer:
+                    "This repository has several remotes and the branch has none chosen yet. It will track the one you pick.",
+                }
+              : {})}
+          >
+            {remotes.map((remoteName) => (
+              <ListChoiceRow
+                key={remoteName}
+                label={remoteName}
+                selected={remoteName === pushRemote}
+                disabled={!gitActions.canWriteSourceControl}
+                onPress={() => void selectRemote(remoteName)}
+              />
+            ))}
+          </ListSection>
+        </ScrollView>
+      </ScreenContent>
+      <SheetHeader
+        title={action ? "Push to which remote?" : "Push remote"}
+        onClose={() => navigation.goBack()}
+      />
+    </View>
+  );
+}

apps/mobile/src/state/use-selected-thread-git-actions.test.ts

@@ -53,7 +53,10 @@ vi.mock("./queries", () => ({
   useBranches: () => ({ data: { refs: state.cachedRefs }, refresh: () => {} }),
 }));
 vi.mock("./use-atom-command", () => ({ useAtomCommand: (command: unknown) => command }));
-vi.mock("./atom-registry", () => ({ appAtomRegistry: {} }));
+vi.mock("./atom-registry", () => ({
+  appAtomRegistry: { get: () => AsyncResult.initial() },
+}));
+vi.mock("@react-navigation/native", () => ({ useNavigation: () => ({ navigate: () => {} }) }));
 vi.mock("./use-remote-environment-registry", () => ({
   environmentConnectedAtom: () => null,
   setPendingConnectionError: () => {},
@@ -84,6 +87,7 @@ vi.mock("./threads", () => ({
 vi.mock("./vcs", () => ({
   vcsEnvironment: {
     readRefs: state.readRefs,
+    status: () => null,
     refreshStatus: async () => {
       state.statusRefreshes += 1;
       return AsyncResult.success({ refName: state.branch });

apps/mobile/src/state/use-selected-thread-git-actions.ts

@@ -1,10 +1,12 @@
+import { useNavigation } from "@react-navigation/native";
 import { useAtomMount } from "@effect/atom-react";
 
 import { EnvironmentProject, EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
 import type { AtomCommandResult } from "@t3tools/client-runtime/state/runtime";
 import {
   createVcsStatusRevalidationAtomFamily,
   type GitActionRequestInput,
+  pushRemoteChoicesFor,
   type VcsActionOperation,
   type VcsRef,
 } from "@t3tools/client-runtime/state/vcs";
@@ -53,12 +55,14 @@ const selectedThreadStatusRevalidation = createVcsStatusRevalidationAtomFamily({
 });
 
 export function useSelectedThreadGitActions() {
+  const navigation = useNavigation();
   const updateThreadMetadata = useAtomCommand(threadEnvironment.updateMetadata, {
     reportFailure: false,
   });
   const readRefs = useAtomCommand(vcsEnvironment.readRefs, { reportFailure: false });
   const refreshStatus = useAtomCommand(vcsEnvironment.refreshStatus, { reportFailure: false });
   const switchRef = useAtomCommand(vcsEnvironment.switchRef, { reportFailure: false });
+  const setPushRemote = useAtomCommand(vcsEnvironment.setPushRemote, { reportFailure: false });
   const createRef = useAtomCommand(vcsEnvironment.createRef, { reportFailure: false });
   const createWorktree = useAtomCommand(vcsEnvironment.createWorktree, { reportFailure: false });
   const pull = useAtomCommand(vcsEnvironment.pull, { reportFailure: false });
@@ -356,9 +360,54 @@ export function useSelectedThreadGitActions() {
     );
   };
 
+  const selectedThreadGitStatus = () =>
+    selectedThread && selectedThreadCwd
+      ? AsyncResult.getOrElse(
+          appAtomRegistry.get(
+            vcsEnvironment.status({
+              environmentId: selectedThread.environmentId,
+              input: { cwd: selectedThreadCwd },
+            }),
+          ),
+          () => null,
+        )
+      : null;
+
+  const onSetSelectedThreadPushRemote = async (remoteName: string) => {
+    const refName = selectedThreadGitStatus()?.refName;
+    if (!refName) return null;
+    return runSelectedThreadGitMutation(
+      "switch_ref",
+      "Changing push remote",
+      async ({ thread, cwd }) => {
+        const result = await setPushRemote({
+          environmentId: thread.environmentId,
+          input: { cwd, refName, remoteName },
+        });
+        if (AsyncResult.isSuccess(result)) {
+          await refreshSelectedThreadGitStatus({ quiet: true, cwd });
+        }
+        return result;
+      },
+    );
+  };
+
   const onRunSelectedThreadGitAction = async (
     input: GitActionRequestInput,
   ): Promise<GitRunStackedActionResult | null> => {
+    // Every entry point lands here, after any default-branch confirmation.
+    const pushRemoteChoices = pushRemoteChoicesFor(input, selectedThreadGitStatus());
+    if (pushRemoteChoices && selectedThread) {
+      navigation.navigate("GitRemote", {
+        environmentId: String(selectedThread.environmentId),
+        threadId: String(selectedThread.id),
+        action: input.action,
+        ...(input.commitMessage ? { commitMessage: input.commitMessage } : {}),
+        ...(input.featureBranch ? { featureBranch: "true" } : {}),
+        ...(input.filePaths?.length ? { filePaths: JSON.stringify(input.filePaths) } : {}),
+      });
+      return null;
+    }
     const actionId = uuidv4();
     return await runSelectedThreadGitMutation(
       "run_change_request",
@@ -370,6 +419,7 @@ export function useSelectedThreadGitActions() {
           ...(input.commitMessage ? { commitMessage: input.commitMessage } : {}),
           ...(input.featureBranch ? { featureBranch: input.featureBranch } : {}),
           ...(input.filePaths?.length ? { filePaths: [...input.filePaths] } : {}),
+          ...(input.pushRemote ? { pushRemote: input.pushRemote } : {}),
           threadId: thread.id,
         });
         if (AsyncResult.isFailure(result)) {
@@ -412,6 +462,7 @@ export function useSelectedThreadGitActions() {
     onCreateSelectedThreadBranch,
     onCreateSelectedThreadWorktree,
     onPullSelectedThreadBranch,
+    onSetSelectedThreadPushRemote,
     onRunSelectedThreadGitAction,
   };
 }