fix(mobile): Reconnect and Retry now on a switched-off environment switch it back on

apps/mobile/src/features/connection/useConnectionController.ts

@@ -38,7 +38,6 @@ export function useConnectionController() {
   const updateBearer = useAtomCommand(updateBearerConnection, { reportFailure: false });
   const registerEnvironment = useAtomCommand(environmentCatalog.register, "environment register");
   const removeEnvironmentMutation = useAtomCommand(environmentCatalog.remove, "environment remove");
-  const retryEnvironmentMutation = useAtomCommand(environmentCatalog.retryNow, "environment retry");
   const setEnvironmentEnabledMutation = useAtomCommand(
     environmentCatalog.setEnabled,
     "environment toggle",
@@ -84,8 +83,6 @@ export function useConnectionController() {
     );
   const removeEnvironment = (environmentId: EnvironmentId) =>
     removeEnvironmentMutation(environmentId);
-  const retryEnvironment = (environmentId: EnvironmentId) =>
-    retryEnvironmentMutation(environmentId);
   const setEnvironmentEnabled = (environmentId: EnvironmentId, enabled: boolean) =>
     setEnvironmentEnabledMutation({ environmentId, enabled });
   const updateEnvironment = (
@@ -111,7 +108,6 @@ export function useConnectionController() {
     connectPairingUrl,
     connectRelayEnvironment,
     removeEnvironment,
-    retryEnvironment,
     setEnvironmentEnabled,
     updateEnvironment,
     refreshRelayEnvironments,

apps/mobile/src/features/connection/useRetryEnvironment.test.tsx

@@ -0,0 +1,108 @@
+import { RegistryContext } from "@effect/atom-react";
+import { EnvironmentId } from "@t3tools/contracts";
+import {
+  EnvironmentRegistry,
+  PrimaryConnectionTarget,
+  type ConnectionCatalogEntry,
+} from "@t3tools/client-runtime/connection";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import { AtomRegistry } from "effect/reactivity";
+import { act, useLayoutEffect } from "react";
+import { createRoot } from "react-dom/client";
+import { describe, expect, it } from "@effect/vitest";
+import { vi } from "vite-plus/test";
+
+const fixture = vi.hoisted(() => ({
+  environment: undefined as
+    | Pick<
+        EnvironmentRegistry.EnvironmentRegistry["Service"],
+        "entries" | "retryNow" | "setEnabled"
+      >
+    | undefined,
+}));
+
+vi.mock("../../connection/runtime", async () => {
+  const { Atom } = await import("effect/reactivity");
+  const Layer = await import("effect/Layer");
+  const { EnvironmentRegistry } = await import("@t3tools/client-runtime/connection");
+  return {
+    connectionAtomRuntime: Atom.runtime(
+      Layer.suspend(() =>
+        Layer.succeed(
+          EnvironmentRegistry.EnvironmentRegistry,
+          fixture.environment as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"],
+        ),
+      ),
+    ),
+  };
+});
+
+import { useRetryEnvironment } from "./useRetryEnvironment";
+
+const environmentId = EnvironmentId.make("retry-environment");
+
+describe("useRetryEnvironment", () => {
+  it.effect.each([
+    { enabled: false, retries: 0 },
+    { enabled: true, retries: 1 },
+  ])("Retry now with the environment enabled: $enabled", ({ enabled, retries }) =>
+    Effect.gen(function* () {
+      (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
+      const target = new PrimaryConnectionTarget({
+        environmentId,
+        label: "Retry",
+        httpBaseUrl: "https://retry.test",
+        wsBaseUrl: "wss://retry.test",
+      });
+      const entries = yield* SubscriptionRef.make<
+        ReadonlyMap<EnvironmentId, ConnectionCatalogEntry>
+      >(new Map([[environmentId, { target, profile: Option.none(), enabled }]]));
+      let retryCount = 0;
+      fixture.environment = {
+        entries,
+        retryNow: () =>
+          Effect.sync(() => {
+            retryCount += 1;
+          }),
+        setEnabled: (id, next) =>
+          SubscriptionRef.update(entries, (current) =>
+            new Map(current).set(id, { ...current.get(id)!, enabled: next }),
+          ),
+      };
+
+      const registry = AtomRegistry.make();
+      const root = createRoot(document.createElement("div"));
+      using _mounted = {
+        [Symbol.dispose]() {
+          act(() => root.unmount());
+          registry.dispose();
+        },
+      };
+      let retryEnvironment!: ReturnType<typeof useRetryEnvironment>;
+      function Probe() {
+        const value = useRetryEnvironment();
+        useLayoutEffect(() => {
+          retryEnvironment = value;
+        });
+        return null;
+      }
+      yield* Effect.promise(async () => {
+        await act(async () =>
+          root.render(
+            <RegistryContext value={registry}>
+              <Probe />
+            </RegistryContext>,
+          ),
+        );
+        await act(async () => {
+          await retryEnvironment(environmentId);
+        });
+      });
+
+      const entry = (yield* SubscriptionRef.get(entries)).get(environmentId);
+      expect({ enabled: entry?.enabled, retries: retryCount }).toEqual({ enabled: true, retries });
+    }),
+  );
+});

apps/mobile/src/features/connection/useRetryEnvironment.ts

@@ -0,0 +1,17 @@
+import { useAtomValue } from "@effect/atom-react";
+import type { EnvironmentId } from "@t3tools/contracts";
+
+import { environmentCatalog } from "../../connection/catalog";
+import { useAtomCommand } from "../../state/use-atom-command";
+
+export function useRetryEnvironment() {
+  const catalog = useAtomValue(environmentCatalog.catalogValueAtom);
+  const retryNow = useAtomCommand(environmentCatalog.retryNow, "environment retry");
+  const setEnabled = useAtomCommand(environmentCatalog.setEnabled, "environment toggle");
+
+  return (environmentId: EnvironmentId) =>
+    // A retry does nothing while the environment is switched off.
+    catalog.entries.get(environmentId)?.enabled === false
+      ? setEnabled({ environmentId, enabled: true })
+      : retryNow(environmentId);
+}

apps/mobile/src/features/files/WorkspaceFilePreviewError.tsx

@@ -2,11 +2,10 @@ import type { EnvironmentId } from "@t3tools/contracts";
 import { View } from "react-native";
 
 import { EmptyState } from "../../components/ui/EmptyState";
-import { environmentCatalog } from "../../connection/catalog";
 import type { AssetUrlFailureReason } from "../../state/asset-url-state";
-import { useAtomCommand } from "../../state/use-atom-command";
 import { useEnvironmentPresentation } from "../../state/presentation";
 import { EnvironmentConnectionNotice } from "../connection/EnvironmentConnectionNotice";
+import { useRetryEnvironment } from "../connection/useRetryEnvironment";
 
 export function WorkspaceFilePreviewError(props: {
   readonly environmentId: EnvironmentId | null;
@@ -15,7 +14,7 @@ export function WorkspaceFilePreviewError(props: {
 }) {
   const { environmentId, onRetry } = props;
   const environment = useEnvironmentPresentation(environmentId);
-  const retryEnvironment = useAtomCommand(environmentCatalog.retryNow, "environment retry");
+  const retryEnvironment = useRetryEnvironment();
   const retryConnection = () => {
     if (environmentId !== null) void retryEnvironment(environmentId);
     onRetry();

apps/mobile/src/features/review/ReviewSheet.tsx

@@ -26,11 +26,10 @@ import {
 import { PaneListItem } from "../../components/ui/PaneListItem";
 import { ScreenContent } from "../../components/ui/ScreenContent";
 import { SheetPane } from "../../components/ui/SheetPane";
-import { environmentCatalog } from "../../connection/catalog";
 import { useEnvironmentPresentation } from "../../state/presentation";
-import { useAtomCommand } from "../../state/use-atom-command";
 import { useThreadDraftForThread } from "../../state/use-thread-composer-state";
 import { EnvironmentConnectionNotice } from "../connection/EnvironmentConnectionNotice";
+import { useRetryEnvironment } from "../connection/useRetryEnvironment";
 import { useAppearancePreferences } from "../settings/appearance/AppearancePreferencesProvider";
 import {
   Inspector,
@@ -351,7 +350,7 @@ export function ReviewSheet(props: ReviewSheetProps) {
   const { themeAppearance: selectedTheme } = useAppearancePreferences();
   const { environmentId, threadId } = props.route.params;
   const environment = useEnvironmentPresentation(environmentId);
-  const retryEnvironment = useAtomCommand(environmentCatalog.retryNow, "environment retry");
+  const retryEnvironment = useRetryEnvironment();
   const isEnvironmentReady = environment.presentation?.connection.phase === "connected";
   const { draftMessage, draftContext } = useThreadDraftForThread({ environmentId, threadId });
   const reviewCache = useReviewCacheForThread({ environmentId, threadId });

apps/mobile/src/features/terminal/ThreadTerminalRouteScreen.tsx

@@ -40,7 +40,6 @@ import { LoadingScreen } from "../../components/LoadingScreen";
 import { ScreenContent } from "../../components/ui/ScreenContent";
 import { Button } from "../../components/ui/Button";
 import { IconButton } from "../../components/ui/IconButton";
-import { environmentCatalog } from "../../connection/catalog";
 import { useEnvironmentPresentation } from "../../state/presentation";
 import { terminalEnvironment } from "../../state/terminal";
 import { environmentSession, readEnvironmentScope } from "../../state/session";
@@ -64,6 +63,7 @@ import {
 import { useThreadSelection } from "../../state/use-thread-selection";
 import { useSelectedThreadProjection } from "../../state/use-thread-detail";
 import { EnvironmentConnectionNotice } from "../connection/EnvironmentConnectionNotice";
+import { useRetryEnvironment } from "../connection/useRetryEnvironment";
 import { TerminalSurface, type TerminalSurfaceHandle } from "./NativeTerminalSurface";
 import { getMobileTerminalTheme } from "./terminalTheme";
 import { useTerminalExitNavigation } from "./useTerminalExitNavigation";
@@ -381,7 +381,7 @@ function ThreadTerminal(props: {
   const navigation = useNavigation();
   const writeTerminal = useAtomCommand(terminalEnvironment.write, "terminal write");
   const clearTerminal = useAtomCommand(terminalEnvironment.clear, "terminal clear");
-  const retryEnvironment = useAtomCommand(environmentCatalog.retryNow, "environment retry");
+  const retryEnvironment = useRetryEnvironment();
   const selectedThreadDetail = useSelectedThreadProjection();
   const selectedThreadDetailWorktreePath =
     selectedThreadDetail?.projection.thread.worktreePath ?? null;

apps/mobile/src/state/use-remote-environment-registry.ts

@@ -9,6 +9,7 @@ import { runAtomCommand } from "@t3tools/client-runtime/state/runtime";
 
 import { hasCloudPublicConfig } from "../features/cloud/publicConfig";
 import { useConnectionController } from "../features/connection/useConnectionController";
+import { useRetryEnvironment } from "../features/connection/useRetryEnvironment";
 import { environmentPresentations } from "./presentation";
 import { useWorkspaceConnectionState, useWorkspaceEnvironments } from "./workspace";
 import type { SavedRemoteConnection } from "../lib/connection";
@@ -166,8 +167,7 @@ export function useRemoteConnections() {
   const onConnectPress = (pairingUrl?: string, expectedEnvironmentId?: EnvironmentId) =>
     pairEnvironment(pairingUrl ?? connectionPairingUrl, expectedEnvironmentId);
 
-  const onReconnectEnvironment = (environmentId: EnvironmentId) =>
-    controller.retryEnvironment(environmentId);
+  const onReconnectEnvironment = useRetryEnvironment();
   const onSetEnvironmentEnabled = (environmentId: EnvironmentId, enabled: boolean) =>
     controller.setEnvironmentEnabled(environmentId, enabled);
   const onUpdateEnvironment = (

apps/mobile/vite.config.ts

@@ -44,6 +44,7 @@ const reactTests = [
   "src/features/home/home-list-options.test.tsx",
   "src/features/home/home-route-visibility.test.tsx",
   "src/features/layout/workspace/useSearchScrollRestoration.test.tsx",
+  "src/features/connection/useRetryEnvironment.test.tsx",
   "src/features/connection/ConnectionsNewRouteScreen.test.tsx",
   "src/features/devices/device-stream.browser.test.ts",
   "src/features/keyboard/keyboardControllerState.test.tsx",