Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Revert "Revert "Add T3 Connect onboarding for mobile and web"" (#3777)

Julius Marmingedad08897664b
diff --git a/apps/mobile/src/Stack.tsx b/apps/mobile/src/Stack.tsx
index 29cf29da9..d68d6f2b9 100644
--- a/apps/mobile/src/Stack.tsx
+++ b/apps/mobile/src/Stack.tsx
@@ -17,6 +17,8 @@ import { AppText as Text } from "./components/AppText";
import { ArchivedThreadsRouteScreen } from "./features/archive/ArchivedThreadsRouteScreen";
import { useAgentNotificationNavigation } from "./features/agent-awareness/notificationNavigation";
import { ClerkSettingsSheetDetentProvider } from "./features/cloud/ClerkSettingsSheetDetent";
+import { ConnectOnboardingRouteScreen } from "./features/cloud/ConnectOnboardingRouteScreen";
+import { useConnectOnboardingNavigation } from "./features/cloud/connectOnboardingNavigation";
import { ThreadFilesTreeScreen, ThreadFileScreen } from "./features/files/ThreadFilesRouteScreen";
import { AdaptiveWorkspaceLayout } from "./features/layout/AdaptiveWorkspaceLayout";
import { HardwareKeyboardCommandProvider } from "./features/keyboard/HardwareKeyboardCommandProvider";
@@ -220,6 +222,7 @@ const NewTaskSheetStack = createNativeStackNavigator({
// influence the adaptive workspace layout: opening Settings over Home should
// not flip the sidebar in or change the active thread.
const WORKSPACE_OVERLAY_ROUTES = new Set([
+ "ConnectOnboarding",
"Connections",
"ConnectionsNew",
"GitBranches",
@@ -251,6 +254,8 @@ function RootStackLayout(props: {
}) {
useAgentNotificationNavigation();
useThreadOutboxDrain();
+ // Presents the T3 Connect onboarding sheet after an in-session sign-in.
+ useConnectOnboardingNavigation();
// Full pathname (sheets included) for keyboard-command scoping; the
// workspace layout only reacts to the underlying non-overlay route.
const path = getPathFromState(props.state, navigationPathConfig);
@@ -412,6 +417,20 @@ export const RootStack = createNativeStackNavigator({
sheetGrabberVisible: true,
},
}),
+ ConnectOnboarding: createNativeStackScreen({
+ screen: ConnectOnboardingRouteScreen,
+ linking: "connect-onboarding",
+ options: {
+ // Root screenOptions hide headers; formSheets that want the native
+ // title bar opt back in with the sheet header preset.
+ ...SHEET_SOLID_HEADER_OPTIONS,
+ title: "Set up T3 Connect",
+ gestureEnabled: true,
+ presentation: "formSheet",
+ sheetAllowedDetents: [0.6, 0.95],
+ sheetGrabberVisible: true,
+ },
+ }),
Connections: createNativeStackScreen({
screen: ConnectionsRouteScreen,
linking: "connections",
diff --git a/apps/mobile/src/connection/platform.ts b/apps/mobile/src/connection/platform.ts
index 769632a8f..fd3c15303 100644
--- a/apps/mobile/src/connection/platform.ts
+++ b/apps/mobile/src/connection/platform.ts
@@ -92,7 +92,7 @@ const capabilitiesLayer = Layer.succeedContext(
if (session === null) {
return yield* new ConnectionBlockedError({
reason: "authentication",
- detail: "Sign in to T3 Cloud to connect this environment.",
+ detail: "Sign in to T3 Connect to connect this environment.",
});
}
const token = yield* session.readClerkToken().pipe(
@@ -107,7 +107,7 @@ const capabilitiesLayer = Layer.succeedContext(
if (token === null) {
return yield* new ConnectionBlockedError({
reason: "authentication",
- detail: "The T3 Cloud session is unavailable.",
+ detail: "The T3 Connect session is unavailable.",
});
}
return token;
diff --git a/apps/mobile/src/features/cloud/CloudAuthProvider.tsx b/apps/mobile/src/features/cloud/CloudAuthProvider.tsx
index 4180ae15c..f7ece97cb 100644
--- a/apps/mobile/src/features/cloud/CloudAuthProvider.tsx
+++ b/apps/mobile/src/features/cloud/CloudAuthProvider.tsx
@@ -18,6 +18,7 @@ import {
setAgentAwarenessRelayTokenProvider,
unregisterAgentAwarenessDeviceForCurrentUser,
} from "../agent-awareness/remoteRegistration";
+import { clearConnectOnboardingRequest, requestConnectOnboarding } from "./connectOnboarding";
import { resolveCloudPublicConfig, resolveRelayClerkTokenOptions } from "./publicConfig";
function resetManagedRelayTokenCache() {
@@ -67,6 +68,19 @@ function CloudAuthBridge(props: { readonly children: ReactNode }) {
const nextAccount = isSignedIn && userId ? userId : null;
observedAccountRef.current = nextAccount;
+ // Every sign-in or account switch that completes during this session (a
+ // cold start observes undefined → account and must not re-prompt) requests
+ // the T3 Connect onboarding sheet — account transitions clear the
+ // connected environments, so each new session starts with no devices to
+ // reach. The request itself is issued after the cleanup transition inside
+ // activateSession, so the sheet never lists the previous account's
+ // environments; sign-out drops any not-yet-presented request instead.
+ const isAccountTransition =
+ previousObservedAccount !== undefined && previousObservedAccount !== nextAccount;
+ if (isAccountTransition && nextAccount === null) {
+ clearConnectOnboardingRequest();
+ }
+
const queueAccountCleanup = (
previous: {
readonly userId: string;
@@ -114,6 +128,9 @@ function CloudAuthBridge(props: { readonly children: ReactNode }) {
}
previousTokenProviderRef.current = { userId, provider: tokenProvider };
activateCloudRelayAccount(userId, tokenProvider);
+ if (isAccountTransition) {
+ requestConnectOnboarding(userId);
+ }
};
const activateAfterTransition = (transition: Promise<void>) => {
void (async () => {
diff --git a/apps/mobile/src/features/cloud/CloudWaitlistEnrollment.tsx b/apps/mobile/src/features/cloud/CloudWaitlistEnrollment.tsx
index dbaf564e9..3bc51e397 100644
--- a/apps/mobile/src/features/cloud/CloudWaitlistEnrollment.tsx
+++ b/apps/mobile/src/features/cloud/CloudWaitlistEnrollment.tsx
@@ -39,7 +39,7 @@ export function CloudWaitlistEnrollment(props: { readonly onSignIn: () => void }
You are on the waitlist
</Text>
<Text className="text-center font-sans text-base text-foreground-secondary">
- We will email you when your T3 Cloud access is ready.
+ We will email you when your T3 Connect access is ready.
</Text>
<SignInAction onPress={props.onSignIn} />
</View>
diff --git a/apps/mobile/src/features/cloud/ConnectOnboardingRouteScreen.tsx b/apps/mobile/src/features/cloud/ConnectOnboardingRouteScreen.tsx
new file mode 100644
index 000000000..657905c8b
--- /dev/null
+++ b/apps/mobile/src/features/cloud/ConnectOnboardingRouteScreen.tsx
@@ -0,0 +1,129 @@
+import { NativeHeaderToolbar } from "../../native/StackHeader";
+import { useAuth } from "@clerk/expo";
+import { StackActions, useNavigation } from "@react-navigation/native";
+import { useCallback, useEffect, useState } from "react";
+import { Pressable, RefreshControl, ScrollView, View } from "react-native";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { reportAtomCommandResult, settlePromise } from "@t3tools/client-runtime/state/runtime";
+import { AppText as Text } from "../../components/AppText";
+import { useRemoteConnections } from "../../state/use-remote-environment-registry";
+import { CloudEnvironmentRows } from "../connection/CloudEnvironmentRows";
+import { splitEnvironmentSections } from "../connection/environmentSections";
+import { useConnectionController } from "../connection/useConnectionController";
+import { optOutOfConnectOnboarding } from "./connectOnboardingOptOut";
+import { hasCloudPublicConfig } from "./publicConfig";
+
+/**
+ * Post-sign-in onboarding sheet for T3 Connect. Mobile never publishes
+ * environments itself — it consumes ones published elsewhere — so this simply
+ * surfaces the account's T3 Connect environments right after sign-in so every
+ * device can be connected in one go. It shows on every sign-in: sign-out
+ * clears the connected environments, so each new session starts from zero.
+ */
+export function ConnectOnboardingRouteScreen() {
+ const navigation = useNavigation();
+
+ // The route is deep-linkable; without cloud config the sheet would present
+ // empty with no chrome to dismiss it, so bail back out instead.
+ useEffect(() => {
+ if (hasCloudPublicConfig()) {
+ return;
+ }
+ if (navigation.canGoBack()) {
+ navigation.goBack();
+ } else {
+ navigation.dispatch(StackActions.replace("Home"));
+ }
+ }, [navigation]);
+
+ return hasCloudPublicConfig() ? <ConfiguredConnectOnboardingRouteScreen /> : null;
+}
+
+function ConfiguredConnectOnboardingRouteScreen() {
+ const navigation = useNavigation();
+ const insets = useSafeAreaInsets();
+ const { isSignedIn, userId } = useAuth({ treatPendingAsSignedOut: false });
+ const { connectedEnvironments, onReconnectEnvironment } = useRemoteConnections();
+ const { refreshRelayEnvironments } = useConnectionController();
+ const { connectedCloudEnvironments } = splitEnvironmentSections({
+ connectedEnvironments,
+ cloudEnvironments: null,
+ });
+
+ // Pull-to-refresh tracks its own spinner instead of discovery's refreshing
+ // flag, so background refreshes (e.g. the sign-in one) don't yank the
+ // content down.
+ const [isPullRefreshing, setIsPullRefreshing] = useState(false);
+ const handlePullRefresh = useCallback(() => {
+ void (async () => {
+ setIsPullRefreshing(true);
+ await refreshRelayEnvironments();
+ setIsPullRefreshing(false);
+ })();
+ }, [refreshRelayEnvironments]);
+
+ const handleClose = useCallback(() => {
+ navigation.goBack();
+ }, [navigation]);
+
+ // Persist before dismissing so a quick sign-out/sign-in cannot race ahead
+ // of the preference write; the write is a local secure-store update.
+ const handleDontShowAgain = useCallback(() => {
+ void (async () => {
+ if (userId) {
+ const result = await settlePromise(() => optOutOfConnectOnboarding(userId));
+ reportAtomCommandResult(result, { label: "connect onboarding opt-out" });
+ }
+ navigation.goBack();
+ })();
+ }, [navigation, userId]);
+
+ return (
+ <View collapsable={false} className="flex-1 bg-sheet">
+ <NativeHeaderToolbar placement="right">
+ <NativeHeaderToolbar.Button icon="xmark" onPress={handleClose} separateBackground />
+ </NativeHeaderToolbar>
+ <ScrollView
+ alwaysBounceVertical
+ contentInsetAdjustmentBehavior="automatic"
+ showsVerticalScrollIndicator={false}
+ style={{ flex: 1 }}
+ contentInset={{ bottom: Math.max(insets.bottom, 18) + 18 }}
+ contentContainerStyle={{
+ gap: 16,
+ paddingHorizontal: 20,
+ paddingTop: 16,
+ }}
+ refreshControl={
+ <RefreshControl refreshing={isPullRefreshing} onRefresh={handlePullRefresh} />
+ }
+ >
+ {isSignedIn ? (
+ <CloudEnvironmentRows
+ connectedCloudEnvironments={connectedCloudEnvironments}
+ onReconnectEnvironment={onReconnectEnvironment}
+ showHeader={false}
+ />
+ ) : (
+ <View collapsable={false} className="rounded-[24px] bg-card p-5">
+ <Text className="text-sm leading-normal text-foreground-muted">
+ Sign in to your T3 account to set up T3 Connect.
+ </Text>
+ </View>
+ )}
+
+ {userId ? (
+ <Pressable
+ accessibilityRole="button"
+ hitSlop={8}
+ onPress={handleDontShowAgain}
+ className="items-center py-1 active:opacity-70"
+ >
+ <Text className="text-xs text-foreground-muted">{"Don't show this again"}</Text>
+ </Pressable>
+ ) : null}
+ </ScrollView>
+ </View>
+ );
+}
diff --git a/apps/mobile/src/features/cloud/connectOnboarding.ts b/apps/mobile/src/features/cloud/connectOnboarding.ts
new file mode 100644
index 000000000..9d3944331
--- /dev/null
+++ b/apps/mobile/src/features/cloud/connectOnboarding.ts
@@ -0,0 +1,24 @@
+import { Atom } from "effect/unstable/reactivity";
+
+import { appAtomRegistry } from "../../state/atom-registry";
+
+// Signals RootStackLayout (inside the navigation tree) that an in-session
+// sign-in just completed. Holds the account id so a sign-out between the
+// request and the navigation cannot present the sheet for the wrong account.
+export const connectOnboardingRequestAtom = Atom.make<string | null>(null).pipe(
+ Atom.keepAlive,
+ Atom.withLabel("mobile:connect-onboarding-request"),
+);
+
+/**
+ * Requests the onboarding sheet for the given account. Sign-out clears the
+ * connected environments, so onboarding runs on every in-session sign-in —
+ * each new session starts with no connected devices.
+ */
+export function requestConnectOnboarding(accountId: string): void {
+ appAtomRegistry.set(connectOnboardingRequestAtom, accountId);
+}
+
+export function clearConnectOnboardingRequest(): void {
+ appAtomRegistry.set(connectOnboardingRequestAtom, null);
+}
diff --git a/apps/mobile/src/features/cloud/connectOnboardingNavigation.ts b/apps/mobile/src/features/cloud/connectOnboardingNavigation.ts
new file mode 100644
index 000000000..f937453e5
--- /dev/null
+++ b/apps/mobile/src/features/cloud/connectOnboardingNavigation.ts
@@ -0,0 +1,49 @@
+import { useAtomValue } from "@effect/atom-react";
+import { useNavigation } from "@react-navigation/native";
+import { useEffect } from "react";
+
+import { appAtomRegistry } from "../../state/atom-registry";
+import { clearConnectOnboardingRequest, connectOnboardingRequestAtom } from "./connectOnboarding";
+import { isConnectOnboardingOptedOut } from "./connectOnboardingOptOut";
+
+// Sign-in happens inside the Settings sheet; give its detent/session-state
+// transitions a beat to settle before presenting another formSheet on top.
+const PRESENT_ONBOARDING_DELAY_MS = 600;
+
+/**
+ * Consumes the onboarding request inside the navigation tree (RootStackLayout)
+ * and presents the onboarding formSheet. Lives apart from connectOnboarding.ts
+ * so non-navigation consumers (CloudAuthProvider) do not pull
+ * @react-navigation into their module graph.
+ */
+export function useConnectOnboardingNavigation(): void {
+ const navigation = useNavigation();
+ const requestedAccountId = useAtomValue(connectOnboardingRequestAtom);
+
+ useEffect(() => {
+ if (requestedAccountId === null) {
+ return;
+ }
+ let cancelled = false;
+ const timer = setTimeout(() => {
+ void (async () => {
+ // A failed preference read prefers showing the sheet.
+ const optedOut = await isConnectOnboardingOptedOut(requestedAccountId).catch(() => false);
+ // The cancelled flag covers effect re-runs, but a sign-out can clear
+ // the request atom moments before this render commits — re-check the
+ // atom so a stale request never presents the sheet.
+ if (cancelled || appAtomRegistry.get(connectOnboardingRequestAtom) !== requestedAccountId) {
+ return;
+ }
+ clearConnectOnboardingRequest();
+ if (!optedOut) {
+ navigation.navigate("ConnectOnboarding");
+ }
+ })();
+ }, PRESENT_ONBOARDING_DELAY_MS);
+ return () => {
+ cancelled = true;
+ clearTimeout(timer);
+ };
+ }, [navigation, requestedAccountId]);
+}
diff --git a/apps/mobile/src/features/cloud/connectOnboardingOptOut.ts b/apps/mobile/src/features/cloud/connectOnboardingOptOut.ts
new file mode 100644
index 000000000..8042bd0aa
--- /dev/null
+++ b/apps/mobile/src/features/cloud/connectOnboardingOptOut.ts
@@ -0,0 +1,21 @@
+import { loadPreferences, updatePreferences } from "../../lib/storage";
+
+// Lives apart from connectOnboarding.ts so CloudAuthProvider (which imports
+// the request signal) never pulls lib/storage — expo-secure-store — into its
+// module graph; that breaks CloudAuthProvider.test.ts suite loading.
+
+/** Whether the account chose "Don't show this again". */
+export async function isConnectOnboardingOptedOut(accountId: string): Promise<boolean> {
+ const preferences = await loadPreferences();
+ return preferences.connectOnboardingOptOutAccounts?.includes(accountId) ?? false;
+}
+
+/** Persists "Don't show this again" for the account. */
+export async function optOutOfConnectOnboarding(accountId: string): Promise<void> {
+ await updatePreferences((current) => {
+ const optedOut = current.connectOnboardingOptOutAccounts ?? [];
+ return optedOut.includes(accountId)
+ ? {}
+ : { connectOnboardingOptOutAccounts: [...optedOut, accountId] };
+ });
+}
diff --git a/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx b/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx
new file mode 100644
index 000000000..854ae37d4
--- /dev/null
+++ b/apps/mobile/src/features/connection/CloudEnvironmentRows.tsx
@@ -0,0 +1,379 @@
+import { useAuth } from "@clerk/expo";
+import { SymbolView } from "expo-symbols";
+import {
+ connectionStatusText,
+ type EnvironmentConnectionPhase,
+} from "@t3tools/client-runtime/connection";
+import type { EnvironmentId } from "@t3tools/contracts";
+import { useCallback, useState } from "react";
+import {
+ ActivityIndicator,
+ Pressable,
+ Switch,
+ type NativeSyntheticEvent,
+ type TextLayoutEventData,
+ View,
+} from "react-native";
+
+import { AppText as Text } from "../../components/AppText";
+import { cn } from "../../lib/cn";
+import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic";
+import { useThemeColor } from "../../lib/useThemeColor";
+import type { ConnectedEnvironmentSummary } from "../../state/remote-runtime-types";
+import { availableCloudEnvironmentPresentation } from "../cloud/cloudEnvironmentPresentation";
+import { ConnectionStatusDot } from "./ConnectionStatusDot";
+import { type RelayEnvironmentView, useConnectionController } from "./useConnectionController";
+
+/**
+ * "T3 Connect" section: every environment published to the signed-in account,
+ * with connect switches, availability status, refresh, and loading/error
+ * states. Shared between the Settings environments screen and the T3 Connect
+ * onboarding sheet.
+ */
+export function CloudEnvironmentRows(props: {
+ readonly connectedCloudEnvironments: ReadonlyArray<ConnectedEnvironmentSummary>;
+ readonly onReconnectEnvironment: (environmentId: EnvironmentId) => void;
+ /**
+ * Hide the "T3 Connect" section title + refresh button for hosts that
+ * provide their own chrome (the onboarding sheet's native header and
+ * pull-to-refresh).
+ */
+ readonly showHeader?: boolean;
+}) {
+ const { isSignedIn } = useAuth({ treatPendingAsSignedOut: false });
+ const controller = useConnectionController();
+ const iconColor = useThemeColor("--color-icon");
+ const availableCloudEnvironments = controller.availableRelayEnvironments;
+ const [expandedErrorId, setExpandedErrorId] = useState<string | null>(null);
+ const hasCloudRows =
+ props.connectedCloudEnvironments.length > 0 || availableCloudEnvironments.length > 0;
+
+ const handleConnectCloudEnvironment = useCallback(
+ (entry: RelayEnvironmentView) => controller.connectRelayEnvironment(entry.environment),
+ [controller],
+ );
+
+ const handleDisconnectCloudEnvironment = useCallback(
+ (environmentId: EnvironmentId) => controller.removeEnvironment(environmentId),
+ [controller],
+ );
+
+ const handleToggleCloudError = useCallback((environmentId: string) => {
+ setExpandedErrorId((current) => (current === environmentId ? null : environmentId));
+ }, []);
+
+ const showHeader = props.showHeader ?? true;
+
+ if (!isSignedIn) return null;
+
+ return (
+ <View collapsable={false} className={cn("gap-3", showHeader && "mt-5")}>
+ {showHeader ? (
+ <View className="flex-row items-center justify-between px-1">
+ <Text className="text-sm font-t3-bold uppercase text-foreground-muted">T3 Connect</Text>
+ <Pressable
+ accessibilityRole="button"
+ disabled={controller.relayDiscovery.isRefreshing}
+ onPress={() => {
+ void controller.refreshRelayEnvironments();
+ }}
+ className="h-9 w-9 items-center justify-center rounded-full bg-subtle active:opacity-70 disabled:opacity-50"
+ >
+ {controller.relayDiscovery.isRefreshing ? (
+ <ActivityIndicator color={iconColor} size="small" />
+ ) : (
+ <SymbolView
+ name="arrow.clockwise"
+ size={14}
+ tintColor={iconColor}
+ type="monochrome"
+ />
+ )}
+ </Pressable>
+ </View>
+ ) : null}
+
+ {hasCloudRows ? (
+ <View collapsable={false} className="overflow-hidden rounded-[24px] bg-card">
+ {props.connectedCloudEnvironments.map((environment, index) => (
+ <ConnectedCloudEnvironmentRow
+ key={environment.environmentId}
+ environment={environment}
+ borderTop={index !== 0}
+ onConnect={() => props.onReconnectEnvironment(environment.environmentId)}
+ onDisconnect={() => handleDisconnectCloudEnvironment(environment.environmentId)}
+ errorExpanded={expandedErrorId === environment.environmentId}
+ onToggleError={() => handleToggleCloudError(environment.environmentId)}
+ />
+ ))}
+ {availableCloudEnvironments.map((environment, index) => (
+ <CloudEnvironmentRow
+ key={environment.environment.environmentId}
+ environment={environment}
+ borderTop={props.connectedCloudEnvironments.length > 0 || index !== 0}
+ onConnect={() => handleConnectCloudEnvironment(environment)}
+ errorExpanded={expandedErrorId === environment.environment.environmentId}
+ onToggleError={() => handleToggleCloudError(environment.environment.environmentId)}
+ />
+ ))}
+ </View>
+ ) : controller.relayDiscovery.isRefreshing ? (
+ <View collapsable={false} className="items-center gap-3 rounded-[24px] bg-card p-6">
+ <ActivityIndicator color={iconColor} />
+ <Text className="text-center text-sm leading-normal text-foreground-muted">
+ Loading linked cloud environments.
+ </Text>
+ </View>
+ ) : controller.relayDiscovery.error ? null : (
+ <View collapsable={false} className="rounded-[24px] bg-card p-5">
+ <Text className="text-sm leading-normal text-foreground-muted">
+ No additional linked cloud environments.
+ </Text>
+ </View>
+ )}
+
+ {/* Rendered alongside any connected rows — a failed discovery must not
+ hide behind an otherwise-healthy list. */}
+ {controller.relayDiscovery.error && !controller.relayDiscovery.isRefreshing ? (
+ <View collapsable={false} className="gap-3 rounded-[24px] bg-card p-5">
+ <Text className="text-base font-t3-bold text-foreground">
+ Could not load T3 Connect environments
+ </Text>
+ <Text className="text-sm text-foreground-muted">{controller.relayDiscovery.error}</Text>
+ {controller.relayDiscovery.errorTraceId ? (
+ <CopyTraceIdButton traceId={controller.relayDiscovery.errorTraceId} />
+ ) : null}
+ <Pressable
+ accessibilityRole="button"
+ onPress={() => {
+ void controller.refreshRelayEnvironments();
+ }}
+ className="self-start rounded-full bg-subtle px-3.5 py-2 active:opacity-70"
+ >
+ <Text className="text-xs font-t3-bold text-foreground">Try again</Text>
+ </Pressable>
+ </View>
+ ) : null}
+ </View>
+ );
+}
+
+function ConnectedCloudEnvironmentRow(props: {
+ readonly environment: ConnectedEnvironmentSummary;
+ readonly borderTop: boolean;
+ readonly errorExpanded: boolean;
+ readonly onConnect: () => void;
+ readonly onDisconnect: () => void;
+ readonly onToggleError: () => void;
+}) {
+ return (
+ <CloudEnvironmentRowShell
+ borderTop={props.borderTop}
+ connectionError={props.environment.connectionError}
+ connectionErrorTraceId={props.environment.connectionErrorTraceId}
+ connectionState={props.environment.connectionState}
+ errorExpanded={props.errorExpanded}
+ label={props.environment.environmentLabel}
+ onValueChange={(enabled) => {
+ if (enabled) {
+ props.onConnect();
+ return;
+ }
+ props.onDisconnect();
+ }}
+ onToggleError={props.onToggleError}
+ value={props.environment.connectionState !== "available"}
+ />
+ );
+}
+
+function CloudEnvironmentRow(props: {
+ readonly environment: RelayEnvironmentView;
+ readonly borderTop: boolean;
+ readonly errorExpanded: boolean;
+ readonly onConnect: () => void;
+ readonly onToggleError: () => void;
+}) {
+ const presentation = availableCloudEnvironmentPresentation({
+ isStatusPending: props.environment.availability === "checking",
+ status: props.environment.status,
+ statusError: props.environment.error,
+ statusErrorTraceId: props.environment.traceId,
+ });
+
+ return (
+ <CloudEnvironmentRowShell
+ borderTop={props.borderTop}
+ connectionError={presentation.connectionError}
+ connectionErrorTraceId={presentation.connectionErrorTraceId}
+ connectionState={presentation.connectionState}
+ errorExpanded={props.errorExpanded}
+ label={props.environment.environment.label}
+ onValueChange={(enabled) => {
+ if (enabled) {
+ props.onConnect();
+ }
+ }}
+ onToggleError={props.onToggleError}
+ statusText={presentation.statusText}
+ value={false}
+ />
+ );
+}
+
+function CloudEnvironmentRowShell(props: {
+ readonly borderTop: boolean;
+ readonly connectionError: string | null;
+ readonly connectionErrorTraceId: string | null;
+ readonly connectionState: EnvironmentConnectionPhase;
+ readonly disabled?: boolean;
+ readonly errorExpanded: boolean;
+ readonly label: string;
+ readonly onToggleError: () => void;
+ readonly onValueChange: (enabled: boolean) => void;
+ readonly statusText?: string;
+ readonly value: boolean;
+}) {
+ const activeTrack = String(useThemeColor("--color-switch-active"));
+ const track = String(useThemeColor("--color-secondary-border"));
+ const chevron = useThemeColor("--color-chevron");
+ const isRetrying =
+ props.connectionState === "connecting" || props.connectionState === "reconnecting";
+ const shouldPulse = isRetrying;
+ const statusText =
+ props.statusText ??
+ connectionStatusText({
+ phase: props.connectionState,
+ error: props.connectionError,
+ traceId: props.connectionErrorTraceId,
+ });
+ const statusClassName = props.connectionError
+ ? "text-rose-500 dark:text-rose-400"
+ : "text-foreground-muted";
+ const [errorMeasurement, setErrorMeasurement] = useState<{
+ readonly text: string;
+ readonly lineCount: number;
+ } | null>(null);
+ const errorTraceId = props.connectionErrorTraceId;
+ const measuredErrorText = errorTraceId ? `${statusText} Trace ID: ${errorTraceId}` : statusText;
+ const errorLineCount =
+ errorMeasurement?.text === measuredErrorText ? errorMeasurement.lineCount : 0;
+ const errorCanExpand = props.connectionError !== null && errorLineCount > 1;
+ const isErrorExpanded = errorCanExpand && props.errorExpanded;
+ const StatusContainer = errorCanExpand ? Pressable : View;
+ const onMeasuredErrorTextLayout = useCallback(
+ (event: NativeSyntheticEvent<TextLayoutEventData>) => {
+ if (!props.connectionError) {
+ return;
+ }
+ const nextLineCount = event.nativeEvent.lines.length;
+ setErrorMeasurement((currentMeasurement) =>
+ currentMeasurement?.text === measuredErrorText &&
+ currentMeasurement.lineCount === nextLineCount
+ ? currentMeasurement
+ : { text: measuredErrorText, lineCount: nextLineCount },
+ );
+ },
+ [measuredErrorText, props.connectionError],
+ );
+ return (
+ <View
+ collapsable={false}
+ className={cn(
+ "flex-row items-center gap-3 bg-card px-4 py-3.5",
+ props.borderTop && "border-t border-border",
+ )}
+ >
+ <View className="min-w-0 flex-1 gap-0.5">
+ <View className="min-w-0 flex-row items-center gap-2">
+ <ConnectionStatusDot state={props.connectionState} pulse={shouldPulse} size={7} />
+ <Text
+ className="min-w-0 flex-shrink text-base font-t3-bold leading-snug text-foreground"
+ numberOfLines={1}
+ >
+ {props.label}
+ </Text>
+ </View>
+ {props.connectionError ? (
+ <Text
+ aria-hidden
+ className={cn("absolute left-0 right-0 text-xs", statusClassName)}
+ onTextLayout={onMeasuredErrorTextLayout}
+ style={{ opacity: 0, zIndex: -1 }}
+ >
+ {measuredErrorText}
+ </Text>
+ ) : null}
+ <StatusContainer
+ {...(errorCanExpand
+ ? { accessibilityRole: "button" as const, onPress: props.onToggleError }
+ : {})}
+ className="min-w-0 flex-row items-start gap-1"
+ >
+ <Text
+ className={cn("min-w-0 flex-1 text-xs", statusClassName)}
+ numberOfLines={isErrorExpanded ? undefined : 1}
+ >
+ {statusText}
+ {errorTraceId ? (
+ <>
+ {" Trace ID: "}
+ <Text
+ accessibilityHint="Copies the trace ID"
+ accessibilityRole="button"
+ className={cn("text-xs underline", statusClassName)}
+ onLongPress={(event) => {
+ event.stopPropagation();
+ copyTextWithHaptic(errorTraceId, { target: "connection-trace-id" });
+ }}
+ onPress={(event) => {
+ event.stopPropagation();
+ }}
+ style={{ textDecorationStyle: "dotted" }}
+ >
+ {errorTraceId}
+ </Text>
+ </>
+ ) : null}
+ </Text>
+ {errorCanExpand ? (
+ <SymbolView
+ name="chevron.down"
+ size={10}
+ tintColor={chevron}
+ type="monochrome"
+ style={{
+ marginTop: 3,
+ transform: [{ rotate: isErrorExpanded ? "180deg" : "0deg" }],
+ }}
+ />
+ ) : null}
+ </StatusContainer>
+ </View>
+ <Switch
+ disabled={props.disabled}
+ ios_backgroundColor={track}
+ onValueChange={props.onValueChange}
+ trackColor={{ false: track, true: activeTrack }}
+ value={props.value}
+ />
+ </View>
+ );
+}
+
+function CopyTraceIdButton(props: { readonly traceId: string }) {
+ const iconColor = useThemeColor("--color-icon");
+
+ return (
+ <Pressable
+ accessibilityRole="button"
+ onPress={() => {
+ copyTextWithHaptic(props.traceId, { target: "connection-trace-id" });
+ }}
+ className="self-start flex-row items-center gap-1.5 rounded-full bg-subtle px-3 py-2 active:opacity-70"
+ >
+ <SymbolView name="doc.on.doc" size={12} tintColor={iconColor} type="monochrome" />
+ <Text className="text-xs font-t3-bold text-foreground">Copy trace ID</Text>
+ </Pressable>
+ );
+}
diff --git a/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx b/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx
index 394bc1801..4b2da3e24 100644
--- a/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx
+++ b/apps/mobile/src/features/connection/ConnectionEnvironmentRow.tsx
@@ -135,7 +135,7 @@ export function ConnectionEnvironmentRow(props: {
>
{props.environment.isRelayManaged ? (
<Text className="text-sm text-foreground-muted">
- Managed by T3 Cloud. Tunnel details update automatically.
+ Managed by T3 Connect. Tunnel details update automatically.
</Text>
) : (
<>
diff --git a/apps/mobile/src/features/connection/environmentSections.test.ts b/apps/mobile/src/features/connection/environmentSections.test.ts
index 497af4bfa..75f78738a 100644
--- a/apps/mobile/src/features/connection/environmentSections.test.ts
+++ b/apps/mobile/src/features/connection/environmentSections.test.ts
@@ -35,7 +35,7 @@ function cloudEnvironment(environmentId: string): RelayClientEnvironmentRecord {
}
describe("mobile environment settings sections", () => {
- it("keeps saved relay-managed connections under T3 Cloud", () => {
+ it("keeps saved relay-managed connections under T3 Connect", () => {
const local = connectedEnvironment({
environmentId: "environment-local",
isRelayManaged: false,
diff --git a/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx
index c8861ec75..d5eecb501 100644
--- a/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx
+++ b/apps/mobile/src/features/settings/SettingsEnvironmentsRouteScreen.tsx
@@ -1,38 +1,18 @@
-import { useAuth } from "@clerk/expo";
import { NativeHeaderToolbar } from "../../native/StackHeader";
import { useNavigation } from "@react-navigation/native";
import { SymbolView } from "expo-symbols";
-import {
- connectionStatusText,
- type EnvironmentConnectionPhase,
-} from "@t3tools/client-runtime/connection";
import type { EnvironmentId } from "@t3tools/contracts";
import { useCallback, useState } from "react";
-import {
- ActivityIndicator,
- Pressable,
- ScrollView,
- Switch,
- type NativeSyntheticEvent,
- type TextLayoutEventData,
- View,
-} from "react-native";
+import { ScrollView, View } from "react-native";
import { useSafeAreaInsets } from "react-native-safe-area-context";
import { AppText as Text } from "../../components/AppText";
-import {
- type RelayEnvironmentView,
- useConnectionController,
-} from "../connection/useConnectionController";
import { hasCloudPublicConfig } from "../cloud/publicConfig";
-import { availableCloudEnvironmentPresentation } from "../cloud/cloudEnvironmentPresentation";
+import { CloudEnvironmentRows } from "../connection/CloudEnvironmentRows";
import { ConnectionEnvironmentRow } from "../connection/ConnectionEnvironmentRow";
-import { ConnectionStatusDot } from "../connection/ConnectionStatusDot";
import { splitEnvironmentSections } from "../connection/environmentSections";
import { cn } from "../../lib/cn";
-import { copyTextWithHaptic } from "../../lib/copyTextWithHaptic";
import { useThemeColor } from "../../lib/useThemeColor";
-import type { ConnectedEnvironmentSummary } from "../../state/remote-runtime-types";
import { useRemoteConnections } from "../../state/use-remote-environment-registry";
export function SettingsEnvironmentsRouteScreen() {
@@ -117,7 +97,7 @@ export function SettingsEnvironmentsRouteScreen() {
)}
{hasCloudPublicConfig() ? (
- <ConfiguredCloudEnvironmentRows
+ <CloudEnvironmentRows
connectedCloudEnvironments={connectedCloudEnvironments}
onReconnectEnvironment={onReconnectEnvironment}
/>
@@ -126,323 +106,3 @@ export function SettingsEnvironmentsRouteScreen() {
</View>
);
}
-
-function ConfiguredCloudEnvironmentRows(props: {
- readonly connectedCloudEnvironments: ReadonlyArray<ConnectedEnvironmentSummary>;
- readonly onReconnectEnvironment: (environmentId: EnvironmentId) => void;
-}) {
- const { isSignedIn } = useAuth({ treatPendingAsSignedOut: false });
- const controller = useConnectionController();
- const iconColor = useThemeColor("--color-icon");
- const availableCloudEnvironments = controller.availableRelayEnvironments;
- const [expandedErrorId, setExpandedErrorId] = useState<string | null>(null);
- const hasCloudRows =
- props.connectedCloudEnvironments.length > 0 || availableCloudEnvironments.length > 0;
-
- const handleConnectCloudEnvironment = useCallback(
- (entry: RelayEnvironmentView) => controller.connectRelayEnvironment(entry.environment),
- [controller],
- );
-
- const handleDisconnectCloudEnvironment = useCallback(
- (environmentId: EnvironmentId) => controller.removeEnvironment(environmentId),
- [controller],
- );
-
- const handleToggleCloudError = useCallback((environmentId: string) => {
- setExpandedErrorId((current) => (current === environmentId ? null : environmentId));
- }, []);
-
- if (!isSignedIn) return null;
-
- return (
- <View collapsable={false} className="mt-5 gap-3">
- <View className="flex-row items-center justify-between px-1">
- <Text className="text-sm font-t3-bold uppercase text-foreground-muted">T3 Cloud</Text>
- <Pressable
- accessibilityRole="button"
- disabled={controller.relayDiscovery.isRefreshing}
- onPress={() => {
- void controller.refreshRelayEnvironments();
- }}
- className="h-9 w-9 items-center justify-center rounded-full bg-subtle active:opacity-70 disabled:opacity-50"
- >
- {controller.relayDiscovery.isRefreshing ? (
- <ActivityIndicator color={iconColor} size="small" />
- ) : (
- <SymbolView name="arrow.clockwise" size={14} tintColor={iconColor} type="monochrome" />
- )}
- </Pressable>
- </View>
-
- {hasCloudRows ? (
- <View collapsable={false} className="overflow-hidden rounded-[24px] bg-card">
- {props.connectedCloudEnvironments.map((environment, index) => (
- <ConnectedCloudEnvironmentRow
- key={environment.environmentId}
- environment={environment}
- borderTop={index !== 0}
- onConnect={() => props.onReconnectEnvironment(environment.environmentId)}
- onDisconnect={() => handleDisconnectCloudEnvironment(environment.environmentId)}
- errorExpanded={expandedErrorId === environment.environmentId}
- onToggleError={() => handleToggleCloudError(environment.environmentId)}
- />
- ))}
- {availableCloudEnvironments.map((environment, index) => (
- <CloudEnvironmentRow
- key={environment.environment.environmentId}
- environment={environment}
- borderTop={props.connectedCloudEnvironments.length > 0 || index !== 0}
- onConnect={() => handleConnectCloudEnvironment(environment)}
- errorExpanded={expandedErrorId === environment.environment.environmentId}
- onToggleError={() => handleToggleCloudError(environment.environment.environmentId)}
- />
- ))}
- </View>
- ) : controller.relayDiscovery.isRefreshing ? (
- <View collapsable={false} className="items-center gap-3 rounded-[24px] bg-card p-6">
- <ActivityIndicator color={iconColor} />
- <Text className="text-center text-sm leading-normal text-foreground-muted">
- Loading linked cloud environments.
- </Text>
- </View>
- ) : controller.relayDiscovery.error ? (
- <View collapsable={false} className="gap-3 rounded-[24px] bg-card p-5">
- <Text className="text-base font-t3-bold text-foreground">
- Could not load T3 Cloud environments
- </Text>
- <Text className="text-sm text-foreground-muted">{controller.relayDiscovery.error}</Text>
- {controller.relayDiscovery.errorTraceId ? (
- <CopyTraceIdButton traceId={controller.relayDiscovery.errorTraceId} />
- ) : null}
- </View>
- ) : (
- <View collapsable={false} className="rounded-[24px] bg-card p-5">
- <Text className="text-sm leading-normal text-foreground-muted">
- No additional linked cloud environments.
- </Text>
- </View>
- )}
- </View>
- );
-}
-
-function ConnectedCloudEnvironmentRow(props: {
- readonly environment: ConnectedEnvironmentSummary;
- readonly borderTop: boolean;
- readonly errorExpanded: boolean;
- readonly onConnect: () => void;
- readonly onDisconnect: () => void;
- readonly onToggleError: () => void;
-}) {
- return (
- <CloudEnvironmentRowShell
- borderTop={props.borderTop}
- connectionError={props.environment.connectionError}
- connectionErrorTraceId={props.environment.connectionErrorTraceId}
- connectionState={props.environment.connectionState}
- errorExpanded={props.errorExpanded}
- label={props.environment.environmentLabel}
- onValueChange={(enabled) => {
- if (enabled) {
- props.onConnect();
- return;
- }
- props.onDisconnect();
- }}
- onToggleError={props.onToggleError}
- value={props.environment.connectionState !== "available"}
- />
- );
-}
-
-function CloudEnvironmentRow(props: {
- readonly environment: RelayEnvironmentView;
- readonly borderTop: boolean;
- readonly errorExpanded: boolean;
- readonly onConnect: () => void;
- readonly onToggleError: () => void;
-}) {
- const presentation = availableCloudEnvironmentPresentation({
- isStatusPending: props.environment.availability === "checking",
- status: props.environment.status,
- statusError: props.environment.error,
- statusErrorTraceId: props.environment.traceId,
- });
-
- return (
- <CloudEnvironmentRowShell
- borderTop={props.borderTop}
- connectionError={presentation.connectionError}
- connectionErrorTraceId={presentation.connectionErrorTraceId}
- connectionState={presentation.connectionState}
- errorExpanded={props.errorExpanded}
- label={props.environment.environment.label}
- onValueChange={(enabled) => {
- if (enabled) {
- props.onConnect();
- }
- }}
- onToggleError={props.onToggleError}
- statusText={presentation.statusText}
- value={false}
- />
- );
-}
-
-function CloudEnvironmentRowShell(props: {
- readonly borderTop: boolean;
- readonly connectionError: string | null;
- readonly connectionErrorTraceId: string | null;
- readonly connectionState: EnvironmentConnectionPhase;
- readonly disabled?: boolean;
- readonly errorExpanded: boolean;
- readonly label: string;
- readonly onToggleError: () => void;
- readonly onValueChange: (enabled: boolean) => void;
- readonly statusText?: string;
- readonly value: boolean;
-}) {
- const activeTrack = String(useThemeColor("--color-switch-active"));
- const track = String(useThemeColor("--color-secondary-border"));
- const chevron = useThemeColor("--color-chevron");
- const isRetrying =
- props.connectionState === "connecting" || props.connectionState === "reconnecting";
- const shouldPulse = isRetrying;
- const statusText =
- props.statusText ??
- connectionStatusText({
- phase: props.connectionState,
- error: props.connectionError,
- traceId: props.connectionErrorTraceId,
- });
- const statusClassName = props.connectionError
- ? "text-rose-500 dark:text-rose-400"
- : "text-foreground-muted";
- const [errorMeasurement, setErrorMeasurement] = useState<{
- readonly text: string;
- readonly lineCount: number;
- } | null>(null);
- const errorTraceId = props.connectionErrorTraceId;
- const measuredErrorText = errorTraceId ? `${statusText} Trace ID: ${errorTraceId}` : statusText;
- const errorLineCount =
- errorMeasurement?.text === measuredErrorText ? errorMeasurement.lineCount : 0;
- const errorCanExpand = props.connectionError !== null && errorLineCount > 1;
- const isErrorExpanded = errorCanExpand && props.errorExpanded;
- const StatusContainer = errorCanExpand ? Pressable : View;
- const onMeasuredErrorTextLayout = useCallback(
- (event: NativeSyntheticEvent<TextLayoutEventData>) => {
- if (!props.connectionError) {
- return;
- }
- const nextLineCount = event.nativeEvent.lines.length;
- setErrorMeasurement((currentMeasurement) =>
- currentMeasurement?.text === measuredErrorText &&
- currentMeasurement.lineCount === nextLineCount
- ? currentMeasurement
- : { text: measuredErrorText, lineCount: nextLineCount },
- );
- },
- [measuredErrorText, props.connectionError],
- );
- return (
- <View
- collapsable={false}
- className={cn(
- "flex-row items-center gap-3 bg-card px-4 py-3.5",
- props.borderTop && "border-t border-border",
- )}
- >
- <View className="min-w-0 flex-1 gap-0.5">
- <View className="min-w-0 flex-row items-center gap-2">
- <ConnectionStatusDot state={props.connectionState} pulse={shouldPulse} size={7} />
- <Text
- className="min-w-0 flex-shrink text-base font-t3-bold leading-snug text-foreground"
- numberOfLines={1}
- >
- {props.label}
- </Text>
- </View>
- {props.connectionError ? (
- <Text
- aria-hidden
- className={cn("absolute left-0 right-0 text-xs", statusClassName)}
- onTextLayout={onMeasuredErrorTextLayout}
- style={{ opacity: 0, zIndex: -1 }}
- >
- {measuredErrorText}
- </Text>
- ) : null}
- <StatusContainer
- {...(errorCanExpand
- ? { accessibilityRole: "button" as const, onPress: props.onToggleError }
- : {})}
- className="min-w-0 flex-row items-start gap-1"
- >
- <Text
- className={cn("min-w-0 flex-1 text-xs", statusClassName)}
- numberOfLines={isErrorExpanded ? undefined : 1}
- >
- {statusText}
- {errorTraceId ? (
- <>
- {" Trace ID: "}
- <Text
- accessibilityHint="Copies the trace ID"
- accessibilityRole="button"
- className={cn("text-xs underline", statusClassName)}
- onLongPress={(event) => {
- event.stopPropagation();
- copyTextWithHaptic(errorTraceId, { target: "connection-trace-id" });
- }}
- onPress={(event) => {
- event.stopPropagation();
- }}
- style={{ textDecorationStyle: "dotted" }}
- >
- {errorTraceId}
- </Text>
- </>
- ) : null}
- </Text>
- {errorCanExpand ? (
- <SymbolView
- name="chevron.down"
- size={10}
- tintColor={chevron}
- type="monochrome"
- style={{
- marginTop: 3,
- transform: [{ rotate: isErrorExpanded ? "180deg" : "0deg" }],
- }}
- />
- ) : null}
- </StatusContainer>
- </View>
- <Switch
- disabled={props.disabled}
- ios_backgroundColor={track}
- onValueChange={props.onValueChange}
- trackColor={{ false: track, true: activeTrack }}
- value={props.value}
- />
- </View>
- );
-}
-
-function CopyTraceIdButton(props: { readonly traceId: string }) {
- const iconColor = useThemeColor("--color-icon");
-
- return (
- <Pressable
- accessibilityRole="button"
- onPress={() => {
- copyTextWithHaptic(props.traceId, { target: "connection-trace-id" });
- }}
- className="self-start flex-row items-center gap-1.5 rounded-full bg-subtle px-3 py-2 active:opacity-70"
- >
- <SymbolView name="doc.on.doc" size={12} tintColor={iconColor} type="monochrome" />
- <Text className="text-xs font-t3-bold text-foreground">Copy trace ID</Text>
- </Pressable>
- );
-}
diff --git a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx
index 2b07b96b3..a4a5499ee 100644
--- a/apps/mobile/src/features/settings/SettingsRouteScreen.tsx
+++ b/apps/mobile/src/features/settings/SettingsRouteScreen.tsx
@@ -240,8 +240,8 @@ function ConfiguredSettingsRouteScreen() {
const promptSignIn = useCallback(() => {
Alert.alert(
- "Request T3 Cloud access",
- "Live Activity updates require approved T3 Cloud access so relay can deliver updates to this device.",
+ "Request T3 Connect access",
+ "Live Activity updates require approved T3 Connect access so relay can deliver updates to this device.",
[
{ text: "Cancel", style: "cancel" },
{
diff --git a/apps/mobile/src/lib/storage.ts b/apps/mobile/src/lib/storage.ts
index 57f7359ec..ae73ac7b4 100644
--- a/apps/mobile/src/lib/storage.ts
+++ b/apps/mobile/src/lib/storage.ts
@@ -69,6 +69,8 @@ export interface Preferences {
/** Code/diff font size override; null/absent means derived from baseFontSize. */
readonly codeFontSize?: number | null;
readonly codeWordBreak?: boolean;
+ /** Cloud account ids that opted out of the T3 Connect onboarding sheet. */
+ readonly connectOnboardingOptOutAccounts?: ReadonlyArray<string>;
}
async function readStorageItem(key: MobileStorageKeyValue): Promise<string | null> {
@@ -167,6 +169,7 @@ export async function loadPreferences(): Promise<Preferences> {
markdownFontSize?: number;
codeFontSize?: number | null;
codeWordBreak?: boolean;
+ connectOnboardingOptOutAccounts?: ReadonlyArray<string>;
} = {};
if (typeof parsed.liveActivitiesEnabled === "boolean") {
@@ -187,18 +190,37 @@ export async function loadPreferences(): Promise<Preferences> {
if (typeof parsed.codeWordBreak === "boolean") {
preferences.codeWordBreak = parsed.codeWordBreak;
}
+ if (Array.isArray(parsed.connectOnboardingOptOutAccounts)) {
+ preferences.connectOnboardingOptOutAccounts = parsed.connectOnboardingOptOutAccounts.filter(
+ (account): account is string => typeof account === "string",
+ );
+ }
return preferences;
}
+// Preference writes are read-modify-write over one JSON blob; concurrent
+// writers would drop each other's fields, so all writes are serialized here.
+let preferencesWriteQueue: Promise<unknown> = Promise.resolve();
+
+export async function updatePreferences(
+ update: (current: Preferences) => Partial<Preferences>,
+): Promise<Preferences> {
+ const task = preferencesWriteQueue.then(async () => {
+ const current = await loadPreferences();
+ const next: Preferences = {
+ ...current,
+ ...update(current),
+ };
+ await writeJsonStorageItem(PREFERENCES_KEY, next);
+ return next;
+ });
+ preferencesWriteQueue = task.catch(() => undefined);
+ return task;
+}
+
export async function savePreferencesPatch(patch: Partial<Preferences>): Promise<Preferences> {
- const current = await loadPreferences();
- const next: Preferences = {
- ...current,
- ...patch,
- };
- await writeJsonStorageItem(PREFERENCES_KEY, next);
- return next;
+ return updatePreferences(() => patch);
}
export async function loadOrCreateAgentAwarenessDeviceId(): Promise<string> {
diff --git a/apps/web/src/cloud/connectOnboarding.ts b/apps/web/src/cloud/connectOnboarding.ts
new file mode 100644
index 000000000..7d61e11c6
--- /dev/null
+++ b/apps/web/src/cloud/connectOnboarding.ts
@@ -0,0 +1,18 @@
+import * as Schema from "effect/Schema";
+
+/**
+ * Accounts that opted out of the post-sign-in T3 Connect onboarding wizard
+ * ("Don't show this again"). The wizard otherwise shows on every sign-in,
+ * since sign-out clears the connected environments.
+ */
+export const CONNECT_ONBOARDING_OPT_OUT_STORAGE_KEY = "t3code:connect-onboarding-opt-out:v1";
+
+export const ConnectOnboardingOptOutSchema = Schema.Struct({
+ optOutAccounts: Schema.Array(Schema.String),
+});
+
+export type ConnectOnboardingOptOutState = typeof ConnectOnboardingOptOutSchema.Type;
+
+export const EMPTY_CONNECT_ONBOARDING_OPT_OUT_STATE: ConnectOnboardingOptOutState = {
+ optOutAccounts: [],
+};
diff --git a/apps/web/src/cloud/useCloudLinkController.ts b/apps/web/src/cloud/useCloudLinkController.ts
new file mode 100644
index 000000000..d91596880
--- /dev/null
+++ b/apps/web/src/cloud/useCloudLinkController.ts
@@ -0,0 +1,163 @@
+import { useAuth } from "@clerk/react";
+import { findErrorTraceId } from "@t3tools/client-runtime/errors";
+import {
+ isAtomCommandInterrupted,
+ settlePromise,
+ squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
+import { useState } from "react";
+
+import { toastManager } from "../components/ui/toast";
+import { relayEnvironmentDiscovery } from "../state/relay";
+import { useAtomCommand } from "../state/use-atom-command";
+import {
+ linkPrimaryEnvironment as linkPrimaryEnvironmentAtom,
+ unlinkPrimaryEnvironment as unlinkPrimaryEnvironmentAtom,
+ updatePrimaryEnvironmentPreferences as updatePrimaryEnvironmentPreferencesAtom,
+} from "./linkEnvironmentAtoms";
+import { usePrimaryCloudLinkState } from "./primaryCloudLinkState";
+import { resolveRelayClerkTokenOptions } from "./publicConfig";
+
+export interface CloudLinkDesiredState {
+ readonly managedTunnel: boolean;
+ readonly publish: boolean;
+}
+
+/**
+ * Drives the primary environment's T3 Connect link. T3 Connect (managed
+ * tunnel) and agent-activity publishing are independent capabilities backed by
+ * a single relay link, so consumers express the full desired state and
+ * `reconcileCloudState` applies it: unlink when neither is wanted, otherwise
+ * (re)link with the mode the managed-tunnel bit implies and set the publish
+ * preference. Re-linking only happens when the managed-tunnel mode actually
+ * changes, so flipping publish alone is cheap.
+ */
+export function useCloudLinkController() {
+ const { getToken, isSignedIn } = useAuth();
+ const refreshRelayEnvironments = useAtomCommand(relayEnvironmentDiscovery.refresh, {
+ reportFailure: false,
+ });
+ const linkPrimaryEnvironment = useAtomCommand(linkPrimaryEnvironmentAtom, {
+ reportFailure: false,
+ });
+ const unlinkPrimaryEnvironment = useAtomCommand(unlinkPrimaryEnvironmentAtom, {
+ reportFailure: false,
+ });
+ const updatePrimaryEnvironmentPreferences = useAtomCommand(
+ updatePrimaryEnvironmentPreferencesAtom,
+ { reportFailure: false },
+ );
+ const primaryCloudLinkState = usePrimaryCloudLinkState();
+ const [operationError, setOperationError] = useState<string | null>(null);
+
+ const reportUpdateFailure = (cause: unknown) => {
+ const message = cause instanceof Error ? cause.message : "Could not update T3 Connect access.";
+ const traceId = findErrorTraceId(cause);
+ console.error("[t3-connect] Could not update T3 Connect", { message, traceId, cause });
+ setOperationError(traceId ? `${message} Trace ID: ${traceId}` : message);
+ toastManager.add({
+ type: "error",
+ title: "Could not update T3 Connect",
+ description: message,
+ data: traceId
+ ? {
+ secondaryActionProps: {
+ children: "Copy trace ID",
+ onClick: () => void navigator.clipboard?.writeText(traceId),
+ },
+ }
+ : undefined,
+ });
+ };
+
+ // Older environment servers predate the managedTunnelActive field; for them a
+ // link always implies a managed tunnel, so fall back to `linked`.
+ const managedTunnelActive =
+ primaryCloudLinkState.data?.managedTunnelActive ?? primaryCloudLinkState.data?.linked ?? false;
+ const publishAgentActivity = primaryCloudLinkState.data?.publishAgentActivity ?? false;
+ const linked = primaryCloudLinkState.data?.linked ?? false;
+
+ const reconcileCloudState = async (desired: CloudLinkDesiredState): Promise<boolean> => {
+ setOperationError(null);
+ const target = primaryCloudLinkState.target;
+ if (!target) {
+ reportUpdateFailure(new Error("Local environment is not ready yet."));
+ return false;
+ }
+ const tokenResult = await settlePromise(() => getToken(resolveRelayClerkTokenOptions()));
+ const wantsLink = desired.managedTunnel || desired.publish;
+
+ // A failure after this point may follow a partially applied mutation (e.g.
+ // the link succeeded but the preference update did not), so every exit —
+ // success or failure — refreshes the rendered state to whatever the server
+ // actually holds now.
+ if (!wantsLink) {
+ // Unlink works without a relay token — a failed token read must not
+ // leave the user unable to turn T3 Connect off.
+ const unlinkResult = await unlinkPrimaryEnvironment({
+ target,
+ clerkToken: tokenResult._tag === "Success" ? (tokenResult.value ?? null) : null,
+ });
+ if (unlinkResult._tag === "Failure") {
+ if (!isAtomCommandInterrupted(unlinkResult)) {
+ reportUpdateFailure(squashAtomCommandFailure(unlinkResult));
+ }
+ primaryCloudLinkState.refresh();
+ return false;
+ }
+ } else {
+ if (tokenResult._tag === "Failure") {
+ reportUpdateFailure(squashAtomCommandFailure(tokenResult));
+ return false;
+ }
+ const clerkToken = tokenResult.value;
+ if (!clerkToken) {
+ reportUpdateFailure(new Error("Sign in to T3 Connect before enabling this."));
+ return false;
+ }
+ if (!linked || managedTunnelActive !== desired.managedTunnel) {
+ const linkResult = await linkPrimaryEnvironment({
+ target,
+ clerkToken,
+ mode: desired.managedTunnel ? "managed" : "publish_only",
+ });
+ if (linkResult._tag === "Failure") {
+ if (!isAtomCommandInterrupted(linkResult)) {
+ reportUpdateFailure(squashAtomCommandFailure(linkResult));
+ }
+ primaryCloudLinkState.refresh();
+ return false;
+ }
+ }
+ const prefResult = await updatePrimaryEnvironmentPreferences({
+ target,
+ publishAgentActivity: desired.publish,
+ });
+ if (prefResult._tag === "Failure") {
+ if (!isAtomCommandInterrupted(prefResult)) {
+ reportUpdateFailure(squashAtomCommandFailure(prefResult));
+ }
+ primaryCloudLinkState.refresh();
+ return false;
+ }
+ }
+
+ primaryCloudLinkState.refresh();
+ const refreshResult = await refreshRelayEnvironments();
+ if (refreshResult._tag === "Failure" && !isAtomCommandInterrupted(refreshResult)) {
+ reportUpdateFailure(squashAtomCommandFailure(refreshResult));
+ return false;
+ }
+ return true;
+ };
+
+ return {
+ isSignedIn,
+ linkState: primaryCloudLinkState,
+ linked,
+ managedTunnelActive,
+ publishAgentActivity,
+ operationError,
+ reconcileCloudState,
+ };
+}
diff --git a/apps/web/src/components/ConnectionStatusDot.tsx b/apps/web/src/components/ConnectionStatusDot.tsx
new file mode 100644
index 000000000..b12acf1ba
--- /dev/null
+++ b/apps/web/src/components/ConnectionStatusDot.tsx
@@ -0,0 +1,56 @@
+import { cn } from "~/lib/utils";
+import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
+
+type ConnectionStatusDotProps = {
+ tooltipText?: string | null;
+ dotClassName: string;
+ pingClassName?: string | null;
+};
+
+export function ConnectionStatusDot({
+ tooltipText,
+ dotClassName,
+ pingClassName,
+}: ConnectionStatusDotProps) {
+ const dotContent = (
+ <>
+ {pingClassName ? (
+ <span
+ className={cn(
+ "absolute inline-flex h-full w-full animate-ping rounded-full",
+ pingClassName,
+ )}
+ />
+ ) : null}
+ <span className={cn("relative inline-flex size-2 rounded-full", dotClassName)} />
+ </>
+ );
+
+ if (!tooltipText) {
+ return (
+ <span className="relative flex size-3 shrink-0 items-center justify-center">
+ {dotContent}
+ </span>
+ );
+ }
+
+ const dot = (
+ <button
+ type="button"
+ title={tooltipText}
+ aria-label={tooltipText}
+ className="relative flex size-3 shrink-0 cursor-help items-center justify-center rounded-full outline-hidden"
+ >
+ {dotContent}
+ </button>
+ );
+
+ return (
+ <Tooltip>
+ <TooltipTrigger render={dot} />
+ <TooltipPopup side="top" className="max-w-80 whitespace-pre-wrap leading-tight">
+ {tooltipText}
+ </TooltipPopup>
+ </Tooltip>
+ );
+}
diff --git a/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx b/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx
new file mode 100644
index 000000000..7f2d63e7a
--- /dev/null
+++ b/apps/web/src/components/cloud/CloudEnvironmentConnectList.tsx
@@ -0,0 +1,227 @@
+import { findErrorTraceId } from "@t3tools/client-runtime/errors";
+import {
+ RelayConnectionRegistration,
+ RelayConnectionTarget,
+} from "@t3tools/client-runtime/connection";
+import {
+ isAtomCommandInterrupted,
+ squashAtomCommandFailure,
+} from "@t3tools/client-runtime/state/runtime";
+import type { EnvironmentId } from "@t3tools/contracts";
+import type { RelayClientEnvironmentRecord } from "@t3tools/contracts/relay";
+import * as Option from "effect/Option";
+import { type ReactNode, useCallback, useEffect, useMemo, useState } from "react";
+
+import { environmentCatalog } from "~/connection/catalog";
+import { cn } from "~/lib/utils";
+import { relayEnvironmentDiscovery } from "~/state/relay";
+import { useRelayEnvironmentDiscovery } from "~/state/environments";
+import { useAtomCommand } from "~/state/use-atom-command";
+import { ConnectionStatusDot } from "../ConnectionStatusDot";
+import { ITEM_ROW_CLASSNAME, ITEM_ROW_INNER_CLASSNAME } from "../settings/itemRows";
+import { Button } from "../ui/button";
+import { Skeleton } from "../ui/skeleton";
+import { toastManager } from "../ui/toast";
+
+export function RemoteEnvironmentRowsSkeleton() {
+ return (
+ <div className={ITEM_ROW_CLASSNAME}>
+ <div className={ITEM_ROW_INNER_CLASSNAME}>
+ <div className="min-w-0 flex-1 space-y-2">
+ <Skeleton className="h-4 w-32 rounded-full" />
+ <Skeleton className="h-3 w-20 rounded-full" />
+ </div>
+ <Skeleton className="h-7 w-16 rounded-md" />
+ </div>
+ </div>
+ );
+}
+
+/**
+ * The user's T3 Connect environments from relay discovery, each with a
+ * Connect button. The primary environment is always excluded; already-saved
+ * environments are hidden unless `showSavedAsConnected` renders them as
+ * connected instead (used by onboarding, where the full device mesh should be
+ * visible).
+ */
+export function CloudEnvironmentConnectRows({
+ primaryEnvironmentId,
+ savedEnvironmentIds,
+ showSavedAsConnected = false,
+ empty = null,
+}: {
+ readonly primaryEnvironmentId: EnvironmentId | null;
+ readonly savedEnvironmentIds: ReadonlyArray<EnvironmentId>;
+ readonly showSavedAsConnected?: boolean;
+ readonly empty?: ReactNode;
+}) {
+ const environmentsState = useRelayEnvironmentDiscovery();
+ const registerEnvironment = useAtomCommand(environmentCatalog.register, {
+ reportFailure: false,
+ });
+ const refreshRelayEnvironments = useAtomCommand(relayEnvironmentDiscovery.refresh, {
+ reportFailure: false,
+ });
+ const connectRelayEnvironment = useCallback(
+ (environment: RelayClientEnvironmentRecord) =>
+ registerEnvironment(
+ new RelayConnectionRegistration({
+ target: new RelayConnectionTarget({
+ environmentId: environment.environmentId,
+ label: environment.label,
+ }),
+ }),
+ ),
+ [registerEnvironment],
+ );
+ const [connectingEnvironmentId, setConnectingEnvironmentId] = useState<EnvironmentId | null>(
+ null,
+ );
+ const savedIds = useMemo(() => new Set(savedEnvironmentIds), [savedEnvironmentIds]);
+
+ useEffect(() => {
+ void refreshRelayEnvironments();
+ }, [refreshRelayEnvironments]);
+
+ const connectEnvironment = async (environment: RelayClientEnvironmentRecord) => {
+ setConnectingEnvironmentId(environment.environmentId);
+ const result = await connectRelayEnvironment(environment);
+ setConnectingEnvironmentId(null);
+ if (result._tag === "Success") {
+ toastManager.add({
+ type: "success",
+ title: "Environment connected",
+ description: `${environment.label} is available through T3 Connect.`,
+ });
+ return;
+ }
+ if (isAtomCommandInterrupted(result)) {
+ return;
+ }
+ const cause = squashAtomCommandFailure(result);
+ const message =
+ cause instanceof Error ? cause.message : "Could not connect the T3 Connect environment.";
+ const traceId = findErrorTraceId(cause);
+ console.error("[t3-connect] Could not connect environment", { message, traceId, cause });
+ toastManager.add({
+ type: "error",
+ title: "Could not connect environment",
+ description: message,
+ data: traceId
+ ? {
+ secondaryActionProps: {
+ children: "Copy trace ID",
+ onClick: () => void navigator.clipboard?.writeText(traceId),
+ },
+ }
+ : undefined,
+ });
+ };
+
+ const visibleEnvironments = [...environmentsState.environments.values()].filter(
+ ({ environment }) =>
+ environment.environmentId !== primaryEnvironmentId &&
+ (showSavedAsConnected || !savedIds.has(environment.environmentId)),
+ );
+
+ const standalone = showSavedAsConnected || savedEnvironmentIds.length === 0;
+
+ if (
+ standalone &&
+ visibleEnvironments.length === 0 &&
+ environmentsState.refreshing &&
+ environmentsState.environments.size === 0
+ ) {
+ return <RemoteEnvironmentRowsSkeleton />;
+ }
+
+ if (standalone && visibleEnvironments.length === 0) {
+ // A failed or offline discovery is not "no environments" — misreporting it
+ // as empty would read as the user's devices having disappeared.
+ const discoveryProblem = environmentsState.offline
+ ? "You appear to be offline."
+ : (Option.getOrNull(environmentsState.error)?.message ?? null);
+ if (discoveryProblem !== null && !environmentsState.refreshing) {
+ return (
+ <div className={ITEM_ROW_CLASSNAME}>
+ <p className="text-sm font-medium text-destructive">
+ Could not load T3 Connect environments
+ </p>
+ <p className="mt-1 text-xs text-muted-foreground">{discoveryProblem}</p>
+ <Button
+ size="sm"
+ variant="outline"
+ className="mt-3"
+ onClick={() => void refreshRelayEnvironments()}
+ >
+ Try again
+ </Button>
+ </div>
+ );
+ }
+ return empty;
+ }
+
+ return visibleEnvironments.map(({ environment, availability, error }) => {
+ const alreadyConnected = savedIds.has(environment.environmentId);
+ return (
+ <div key={environment.environmentId} className={ITEM_ROW_CLASSNAME}>
+ <div className={ITEM_ROW_INNER_CLASSNAME}>
+ <div className="min-w-0">
+ <div className="flex items-center gap-2">
+ <ConnectionStatusDot
+ dotClassName={
+ availability === "online"
+ ? "bg-success"
+ : availability === "error"
+ ? "bg-destructive"
+ : availability === "checking"
+ ? "bg-warning"
+ : "bg-muted-foreground/35"
+ }
+ pingClassName={availability === "checking" ? "bg-warning/60 duration-2000" : null}
+ tooltipText={
+ availability === "online"
+ ? "Relay online"
+ : availability === "offline"
+ ? "Relay offline"
+ : availability === "checking"
+ ? "Checking relay status"
+ : (Option.getOrNull(error)?.message ?? "Relay status unavailable")
+ }
+ />
+ <p className="truncate text-sm font-medium">{environment.label}</p>
+ </div>
+ <p
+ className={cn(
+ "mt-1 truncate text-xs",
+ availability === "error" ? "text-destructive" : "text-muted-foreground",
+ )}
+ >
+ {availability === "online"
+ ? "Available · Relay online"
+ : availability === "offline"
+ ? "Available · Relay offline"
+ : availability === "checking"
+ ? "Available · Checking relay status…"
+ : (Option.getOrNull(error)?.message ?? "Available · Relay status unavailable")}
+ </p>
+ </div>
+ {alreadyConnected ? (
+ <Button size="sm" variant="outline" disabled>
+ Connected
+ </Button>
+ ) : (
+ <Button
+ size="sm"
+ disabled={connectingEnvironmentId !== null}
+ onClick={() => void connectEnvironment(environment)}
+ >
+ {connectingEnvironmentId === environment.environmentId ? "Connecting…" : "Connect"}
+ </Button>
+ )}
+ </div>
+ </div>
+ );
+ });
+}
diff --git a/apps/web/src/components/cloud/ConnectOnboardingDialog.tsx b/apps/web/src/components/cloud/ConnectOnboardingDialog.tsx
new file mode 100644
index 000000000..e79d20e28
--- /dev/null
+++ b/apps/web/src/components/cloud/ConnectOnboardingDialog.tsx
@@ -0,0 +1,437 @@
+import { useAuth } from "@clerk/react";
+import { AuthAdministrativeScopes, AuthRelayWriteScope } from "@t3tools/contracts";
+import { CheckIcon } from "lucide-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import {
+ CONNECT_ONBOARDING_OPT_OUT_STORAGE_KEY,
+ ConnectOnboardingOptOutSchema,
+ EMPTY_CONNECT_ONBOARDING_OPT_OUT_STATE,
+} from "~/cloud/connectOnboarding";
+import { hasCloudPublicConfig } from "~/cloud/publicConfig";
+import { useCloudLinkController } from "~/cloud/useCloudLinkController";
+import { usePrimarySessionState } from "~/environments/primary";
+import { useLocalStorage } from "~/hooks/useLocalStorage";
+import { cn } from "~/lib/utils";
+import { useEnvironments, usePrimaryEnvironment } from "~/state/environments";
+import { CloudEnvironmentConnectRows } from "./CloudEnvironmentConnectList";
+import { Button } from "../ui/button";
+import { Checkbox } from "../ui/checkbox";
+import {
+ Dialog,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogPanel,
+ DialogPopup,
+ DialogTitle,
+} from "../ui/dialog";
+import { Switch } from "../ui/switch";
+import { toastManager } from "../ui/toast";
+
+/**
+ * Post-sign-in onboarding wizard for T3 Connect. Opens on every in-session
+ * sign-in — sign-out removes the connected relay environments, so each new
+ * session starts with no devices to reach. It first prompts to publish this
+ * environment (managed tunnel + agent activity, both defaulting on) when the
+ * current session is authorized to manage the relay link, then lists the
+ * account's T3 Connect environments so every device can be connected right
+ * away. A cold load with a restored session does not count as a sign-in.
+ */
+export function ConnectOnboardingDialog() {
+ if (!hasCloudPublicConfig()) return null;
+
+ return <ConfiguredConnectOnboardingDialog />;
+}
+
+type OnboardingStep = "publish" | "devices";
+
+function ConfiguredConnectOnboardingDialog() {
+ // Mirrors ManagedRelayAuthProvider: a pending Clerk session must not read as
+ // signed-out, or its later activation would look like a fresh sign-in.
+ const { isLoaded, isSignedIn, userId } = useAuth({ treatPendingAsSignedOut: false });
+ const [optOutState, setOptOutState] = useLocalStorage(
+ CONNECT_ONBOARDING_OPT_OUT_STORAGE_KEY,
+ EMPTY_CONNECT_ONBOARDING_OPT_OUT_STATE,
+ ConnectOnboardingOptOutSchema,
+ );
+
+ const desktopBridge = window.desktopBridge;
+ const primarySessionState = usePrimarySessionState();
+ const currentSessionScopes = desktopBridge
+ ? AuthAdministrativeScopes
+ : primarySessionState.data?.authenticated
+ ? (primarySessionState.data.scopes ?? null)
+ : null;
+ const canManageRelay = currentSessionScopes?.includes(AuthRelayWriteScope) ?? false;
+ // The publish step is only offered when we know the answer; opening the
+ // wizard before the session state resolves would let the step set change
+ // mid-flight. A failed session read still opens the wizard — it just means
+ // no publish step.
+ const sessionScopesKnown =
+ Boolean(desktopBridge) ||
+ primarySessionState.data !== null ||
+ primarySessionState.error !== null;
+
+ const controller = useCloudLinkController();
+ const showPublishStep = canManageRelay && controller.linkState.target !== null;
+ const steps: ReadonlyArray<OnboardingStep> = showPublishStep
+ ? ["publish", "devices"]
+ : ["devices"];
+
+ const [requestedAccount, setRequestedAccount] = useState<string | null>(null);
+ const [openForAccount, setOpenForAccount] = useState<string | null>(null);
+ const [step, setStep] = useState<OnboardingStep>("devices");
+ const [exposeEnvironment, setExposeEnvironment] = useState(true);
+ const [publishAgentActivity, setPublishAgentActivity] = useState(true);
+ const [dontShowAgain, setDontShowAgain] = useState(false);
+ const [isApplying, setIsApplying] = useState(false);
+ const prefilledFromLinkStateRef = useRef(false);
+ const observedAccountRef = useRef<string | null | undefined>(undefined);
+
+ const optOutAccounts = optOutState.optOutAccounts;
+
+ // Every sign-in or account switch that completes during this session
+ // requests the wizard — account transitions clear the connected relay
+ // environments, so each new session starts with no devices to reach. A cold
+ // load observes undefined → account and must not re-prompt.
+ useEffect(() => {
+ if (!isLoaded) return;
+ // A loaded-but-incomplete snapshot (signed in, user id not yet populated)
+ // must not be recorded as signed-out — the next render would then look
+ // like a fresh sign-in on a cold load.
+ if (isSignedIn && !userId) return;
+ const previousAccount = observedAccountRef.current;
+ const nextAccount = isSignedIn && userId ? userId : null;
+ observedAccountRef.current = nextAccount;
+ if (previousAccount !== undefined && previousAccount !== nextAccount && nextAccount !== null) {
+ setRequestedAccount(nextAccount);
+ }
+ }, [isLoaded, isSignedIn, userId]);
+
+ // A manageable session implies a primary environment, so when the scopes
+ // allow publishing, wait for the connection target too — otherwise the
+ // wizard could open on the devices step moments before the publish step
+ // becomes available and freeze there.
+ const publishStepDecided = !canManageRelay || controller.linkState.target !== null;
+
+ // Open once the session scopes resolve so the step set is stable. Accounts
+ // that chose "Don't show this again" are skipped.
+ useEffect(() => {
+ if (requestedAccount === null || openForAccount !== null) return;
+ if (optOutAccounts.includes(requestedAccount)) {
+ setRequestedAccount(null);
+ return;
+ }
+ if (!sessionScopesKnown || !publishStepDecided) return;
+ setRequestedAccount(null);
+ prefilledFromLinkStateRef.current = false;
+ setExposeEnvironment(true);
+ setPublishAgentActivity(true);
+ setDontShowAgain(false);
+ setStep(canManageRelay && controller.linkState.target !== null ? "publish" : "devices");
+ setOpenForAccount(requestedAccount);
+ }, [
+ canManageRelay,
+ controller.linkState.target,
+ openForAccount,
+ optOutAccounts,
+ publishStepDecided,
+ requestedAccount,
+ sessionScopesKnown,
+ ]);
+
+ // Signing out (or switching accounts) mid-wizard invalidates everything the
+ // wizard would do — close it and let the sign-in trigger re-evaluate.
+ useEffect(() => {
+ if (openForAccount !== null && (!isSignedIn || userId !== openForAccount)) {
+ setOpenForAccount(null);
+ }
+ if (requestedAccount !== null && (!isSignedIn || userId !== requestedAccount)) {
+ setRequestedAccount(null);
+ }
+ }, [isSignedIn, openForAccount, requestedAccount, userId]);
+
+ // Toggles default on, but an environment that is already linked should show
+ // its actual configuration instead of silently proposing to rewrite it.
+ // Only when the link belongs to the account being onboarded, though — after
+ // an account switch the cached link state can still describe the previous
+ // account's setup.
+ const linkStateData = controller.linkState.data;
+ useEffect(() => {
+ if (openForAccount === null || prefilledFromLinkStateRef.current || linkStateData === null) {
+ return;
+ }
+ prefilledFromLinkStateRef.current = true;
+ if (linkStateData.linked && linkStateData.cloudUserId === openForAccount) {
+ setExposeEnvironment(linkStateData.managedTunnelActive ?? linkStateData.linked);
+ setPublishAgentActivity(linkStateData.publishAgentActivity);
+ }
+ }, [linkStateData, openForAccount]);
+
+ const complete = () => {
+ // Keep the wizard up while a link request is in flight so its outcome
+ // (and any failure) stays visible.
+ if (isApplying) return;
+ const account = openForAccount;
+ setOpenForAccount(null);
+ if (account !== null && dontShowAgain) {
+ setOptOutState((state) =>
+ state.optOutAccounts.includes(account)
+ ? state
+ : { optOutAccounts: [...state.optOutAccounts, account] },
+ );
+ }
+ };
+
+ const applyPublishSelection = async () => {
+ // The wizard only ever enables — with both toggles off there is nothing to
+ // apply, and an existing link must not be torn down from onboarding.
+ if (!exposeEnvironment && !publishAgentActivity) {
+ setStep("devices");
+ return;
+ }
+ setIsApplying(true);
+ const ok = await controller.reconcileCloudState({
+ managedTunnel: exposeEnvironment,
+ publish: publishAgentActivity,
+ });
+ setIsApplying(false);
+ if (!ok) return;
+ toastManager.add({
+ type: "success",
+ title: "T3 Connect enabled",
+ description: exposeEnvironment
+ ? "This environment is available to your other devices through T3 Connect."
+ : "This environment publishes agent activity to your mobile clients.",
+ });
+ setStep("devices");
+ };
+
+ return (
+ <Dialog
+ open={openForAccount !== null}
+ onOpenChange={(open) => {
+ // Keep the dialog up while a link request is in flight so its outcome
+ // (and any failure) stays visible.
+ if (!open && !isApplying) complete();
+ }}
+ >
+ <DialogPopup className="max-w-xl">
+ <DialogHeader>
+ <DialogTitle>Set up T3 Connect</DialogTitle>
+ <DialogDescription>
+ Mesh your devices together — publish this environment and connect the rest, all in one
+ place.
+ </DialogDescription>
+ {steps.length > 1 ? (
+ <OnboardingStepper
+ steps={steps}
+ currentStep={step}
+ disabled={isApplying}
+ onStepSelect={setStep}
+ />
+ ) : null}
+ </DialogHeader>
+ <DialogPanel>
+ {step === "publish" ? (
+ <PublishStep
+ exposeEnvironment={exposeEnvironment}
+ publishAgentActivity={publishAgentActivity}
+ disabled={isApplying}
+ operationError={controller.operationError}
+ onExposeEnvironmentChange={setExposeEnvironment}
+ onPublishAgentActivityChange={setPublishAgentActivity}
+ />
+ ) : (
+ <DevicesStep />
+ )}
+ </DialogPanel>
+ <DialogFooter variant="bare" className="sm:justify-between">
+ <label className="flex cursor-pointer items-center gap-2 self-start text-xs text-muted-foreground sm:self-center">
+ <Checkbox
+ checked={dontShowAgain}
+ onCheckedChange={(checked) => setDontShowAgain(checked === true)}
+ />
+ Don&apos;t show this again
+ </label>
+ <div className="flex flex-col-reverse gap-2 sm:flex-row">
+ {step === "publish" ? (
+ <>
+ <Button variant="ghost" disabled={isApplying} onClick={() => setStep("devices")}>
+ Not now
+ </Button>
+ <Button
+ disabled={
+ isApplying || (controller.linkState.isPending && linkStateData === null)
+ }
+ onClick={() => void applyPublishSelection()}
+ >
+ {isApplying ? "Enabling…" : "Continue"}
+ </Button>
+ </>
+ ) : (
+ <Button disabled={isApplying} onClick={complete}>
+ Done
+ </Button>
+ )}
+ </div>
+ </DialogFooter>
+ </DialogPopup>
+ </Dialog>
+ );
+}
+
+const STEP_LABELS: Record<OnboardingStep, string> = {
+ publish: "Publish",
+ devices: "Connect devices",
+};
+
+function OnboardingStepper({
+ steps,
+ currentStep,
+ disabled,
+ onStepSelect,
+}: {
+ readonly steps: ReadonlyArray<OnboardingStep>;
+ readonly currentStep: OnboardingStep;
+ readonly disabled: boolean;
+ readonly onStepSelect: (step: OnboardingStep) => void;
+}) {
+ const currentIndex = steps.indexOf(currentStep);
+ return (
+ <div className="grid grid-cols-2 gap-2">
+ {steps.map((step, index) => (
+ <button
+ key={step}
+ type="button"
+ disabled={disabled}
+ className={cn(
+ "grid min-w-0 grid-cols-[1rem_minmax(0,1fr)] gap-x-2 rounded-lg border px-3 py-2 text-left",
+ index === currentIndex
+ ? "border-primary bg-primary/10 ring-1 ring-primary/25"
+ : index < currentIndex
+ ? "border-border bg-background"
+ : "border-border bg-muted/40",
+ )}
+ onClick={() => onStepSelect(step)}
+ >
+ <span
+ className={cn(
+ "row-span-2 mt-0.5 grid size-4 place-items-center rounded-full border",
+ index < currentIndex
+ ? "border-primary bg-primary text-primary-foreground"
+ : index === currentIndex
+ ? "border-primary bg-background"
+ : "border-muted-foreground/35 bg-background",
+ )}
+ aria-hidden
+ >
+ {index < currentIndex ? <CheckIcon className="size-3" /> : null}
+ </span>
+ <span className="text-[10px] font-medium uppercase text-muted-foreground">
+ Step {index + 1}
+ </span>
+ <span className="truncate text-xs font-semibold text-foreground">
+ {STEP_LABELS[step]}
+ </span>
+ </button>
+ ))}
+ </div>
+ );
+}
+
+function PublishStep({
+ exposeEnvironment,
+ publishAgentActivity,
+ disabled,
+ operationError,
+ onExposeEnvironmentChange,
+ onPublishAgentActivityChange,
+}: {
+ readonly exposeEnvironment: boolean;
+ readonly publishAgentActivity: boolean;
+ readonly disabled: boolean;
+ readonly operationError: string | null;
+ readonly onExposeEnvironmentChange: (enabled: boolean) => void;
+ readonly onPublishAgentActivityChange: (enabled: boolean) => void;
+}) {
+ return (
+ <div className="space-y-3">
+ <div className="rounded-lg border">
+ <OnboardingToggleRow
+ title="Publish this environment"
+ description="Make this environment available to your other devices through T3 Connect."
+ checked={exposeEnvironment}
+ disabled={disabled}
+ onCheckedChange={onExposeEnvironmentChange}
+ />
+ <OnboardingToggleRow
+ title="Publish agent activity"
+ description="Send activity from this environment to your mobile clients for push notifications and Live Activities."
+ checked={publishAgentActivity}
+ disabled={disabled}
+ onCheckedChange={onPublishAgentActivityChange}
+ />
+ </div>
+ {operationError ? <p className="text-xs text-destructive">{operationError}</p> : null}
+ </div>
+ );
+}
+
+function OnboardingToggleRow({
+ title,
+ description,
+ checked,
+ disabled,
+ onCheckedChange,
+}: {
+ readonly title: string;
+ readonly description: string;
+ readonly checked: boolean;
+ readonly disabled: boolean;
+ readonly onCheckedChange: (enabled: boolean) => void;
+}) {
+ return (
+ <div className="flex items-start justify-between gap-4 border-t border-border/60 px-4 py-3 first:border-t-0">
+ <div className="min-w-0">
+ <p className="text-sm font-medium">{title}</p>
+ <p className="mt-1 text-xs text-muted-foreground">{description}</p>
+ </div>
+ <Switch
+ aria-label={title}
+ checked={checked}
+ disabled={disabled}
+ onCheckedChange={onCheckedChange}
+ />
+ </div>
+ );
+}
+
+function DevicesStep() {
+ const { environments } = useEnvironments();
+ const primaryEnvironment = usePrimaryEnvironment();
+ const savedEnvironmentIds = useMemo(
+ () =>
+ environments
+ .filter((environment) => environment.entry.target._tag !== "PrimaryConnectionTarget")
+ .map((environment) => environment.environmentId),
+ [environments],
+ );
+
+ return (
+ <div className="overflow-hidden rounded-lg border">
+ <CloudEnvironmentConnectRows
+ primaryEnvironmentId={primaryEnvironment?.environmentId ?? null}
+ savedEnvironmentIds={savedEnvironmentIds}
+ showSavedAsConnected
+ empty={
+ <p className="px-4 py-6 text-center text-sm text-muted-foreground">
+ No other environments are published to your account yet. Publish one from another device
+ and it will show up here.
+ </p>
+ }
+ />
+ </div>
+ );
+}
diff --git a/apps/web/src/components/settings/ConnectionsSettings.tsx b/apps/web/src/components/settings/ConnectionsSettings.tsx
index f058a1cc6..ebde77f3e 100644
--- a/apps/web/src/components/settings/ConnectionsSettings.tsx
+++ b/apps/web/src/components/settings/ConnectionsSettings.tsx
@@ -7,8 +7,7 @@ import {
TerminalIcon,
TriangleAlertIcon,
} from "lucide-react";
-import { useAuth } from "@clerk/react";
-import { type ReactNode, memo, useCallback, useEffect, useMemo, useState } from "react";
+import { type ReactNode, memo, useCallback, useMemo, useState } from "react";
import {
AuthAccessReadScope,
AuthAccessWriteScope,
@@ -30,18 +29,11 @@ import {
type DesktopWslState,
type EnvironmentId,
} from "@t3tools/contracts";
-import {
- connectionStatusText,
- RelayConnectionRegistration,
- RelayConnectionTarget,
-} from "@t3tools/client-runtime/connection";
-import { findErrorTraceId } from "@t3tools/client-runtime/errors";
+import { connectionStatusText } from "@t3tools/client-runtime/connection";
import {
isAtomCommandInterrupted,
- settlePromise,
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
-import type { RelayClientEnvironmentRecord } from "@t3tools/contracts/relay";
import * as DateTime from "effect/DateTime";
import * as Option from "effect/Option";
@@ -50,7 +42,6 @@ import { cn } from "../../lib/utils";
import { formatElapsedDurationLabel, formatExpiresInLabel } from "../../timestampFormat";
import { resolveDesktopPairingUrl, resolveHostedPairingUrl } from "./pairingUrls";
import { applyWslEnableSelection } from "./ConnectionsSettings.logic";
-import { resolveRelayClerkTokenOptions } from "../../cloud/publicConfig";
import {
SettingsPageContainer,
SettingsRow,
@@ -82,7 +73,6 @@ import {
} from "../ui/alert-dialog";
import { Popover, PopoverPopup, PopoverTrigger } from "../ui/popover";
import { QRCodeSvg } from "../ui/qr-code";
-import { Skeleton } from "../ui/skeleton";
import { Spinner } from "../ui/spinner";
import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select";
import { Switch } from "../ui/switch";
@@ -117,13 +107,8 @@ import {
import { isDesktopLocalConnectionTarget } from "~/connection/desktopLocal";
import { useUiStateStore } from "~/uiStateStore";
import { resolveServerConfigVersionMismatch } from "~/versionSkew";
-import { usePrimaryCloudLinkState } from "~/cloud/primaryCloudLinkState";
import { hasCloudPublicConfig } from "~/cloud/publicConfig";
-import {
- linkPrimaryEnvironment as linkPrimaryEnvironmentAtom,
- unlinkPrimaryEnvironment as unlinkPrimaryEnvironmentAtom,
- updatePrimaryEnvironmentPreferences as updatePrimaryEnvironmentPreferencesAtom,
-} from "~/cloud/linkEnvironmentAtoms";
+import { useCloudLinkController } from "~/cloud/useCloudLinkController";
import { authEnvironment } from "~/state/auth";
import { environmentCatalog } from "~/connection/catalog";
import {
@@ -141,10 +126,11 @@ import {
type EnvironmentPresentation,
useEnvironments,
usePrimaryEnvironment,
- useRelayEnvironmentDiscovery,
} from "~/state/environments";
-import { relayEnvironmentDiscovery } from "~/state/relay";
import { useAtomCommand } from "../../state/use-atom-command";
+import { ConnectionStatusDot } from "../ConnectionStatusDot";
+import { CloudEnvironmentConnectRows } from "../cloud/CloudEnvironmentConnectList";
+import { ITEM_ROW_CLASSNAME, ITEM_ROW_INNER_CLASSNAME } from "./itemRows";
const DEFAULT_TAILSCALE_SERVE_PORT = 443;
const EMPTY_ADVERTISED_ENDPOINTS: ReadonlyArray<AdvertisedEndpoint> = [];
@@ -260,60 +246,6 @@ function AccessScopeSummary({
);
}
-type ConnectionStatusDotProps = {
- tooltipText?: string | null;
- dotClassName: string;
- pingClassName?: string | null;
-};
-
-function ConnectionStatusDot({
- tooltipText,
- dotClassName,
- pingClassName,
-}: ConnectionStatusDotProps) {
- const dotContent = (
- <>
- {pingClassName ? (
- <span
- className={cn(
- "absolute inline-flex h-full w-full animate-ping rounded-full",
- pingClassName,
- )}
- />
- ) : null}
- <span className={cn("relative inline-flex size-2 rounded-full", dotClassName)} />
- </>
- );
-
- if (!tooltipText) {
- return (
- <span className="relative flex size-3 shrink-0 items-center justify-center">
- {dotContent}
- </span>
- );
- }
-
- const dot = (
- <button
- type="button"
- title={tooltipText}
- aria-label={tooltipText}
- className="relative flex size-3 shrink-0 cursor-help items-center justify-center rounded-full outline-hidden"
- >
- {dotContent}
- </button>
- );
-
- return (
- <Tooltip>
- <TooltipTrigger render={dot} />
- <TooltipPopup side="top" className="max-w-80 whitespace-pre-wrap leading-tight">
- {tooltipText}
- </TooltipPopup>
- </Tooltip>
- );
-}
-
function formatDesktopSshTarget(target: DesktopSshEnvironmentTarget): string {
const authority = target.username ? `${target.username}@${target.hostname}` : target.hostname;
return target.port ? `${authority}:${target.port}` : authority;
@@ -437,13 +369,8 @@ function formatDesktopSshConnectionError(error: unknown): string {
return withoutTaggedErrorPrefix.trim() || fallback;
}
-/** Direct row in the card – same pattern as the Provider / ACP-agent list rows. */
-const ITEM_ROW_CLASSNAME = "border-t border-border/60 px-4 py-4 first:border-t-0 sm:px-5";
const ENDPOINT_ROW_CLASSNAME = "border-t border-border/60 px-4 py-2.5 first:border-t-0 sm:px-5";
-const ITEM_ROW_INNER_CLASSNAME =
- "flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between";
-
type AccessSectionPresentation = "current" | "endpoint-rail";
function accessRowClassName(_presentation: AccessSectionPresentation) {
@@ -1629,51 +1556,17 @@ function CloudLinkSwitch({
}
function ConfiguredCloudLinkRow({ canManageRelay }: { readonly canManageRelay: boolean }) {
- const { getToken, isSignedIn } = useAuth();
- const refreshRelayEnvironments = useAtomCommand(relayEnvironmentDiscovery.refresh, {
- reportFailure: false,
- });
- const linkPrimaryEnvironment = useAtomCommand(linkPrimaryEnvironmentAtom, {
- reportFailure: false,
- });
- const unlinkPrimaryEnvironment = useAtomCommand(unlinkPrimaryEnvironmentAtom, {
- reportFailure: false,
- });
- const updatePrimaryEnvironmentPreferences = useAtomCommand(
- updatePrimaryEnvironmentPreferencesAtom,
- { reportFailure: false },
- );
- const primaryCloudLinkState = usePrimaryCloudLinkState();
- const [operationError, setOperationError] = useState<string | null>(null);
+ const {
+ isSignedIn,
+ linkState: primaryCloudLinkState,
+ managedTunnelActive,
+ publishAgentActivity,
+ operationError,
+ reconcileCloudState,
+ } = useCloudLinkController();
const [isUpdating, setIsUpdating] = useState(false);
const [isUpdatingPreference, setIsUpdatingPreference] = useState(false);
- const reportUpdateFailure = (cause: unknown) => {
- const message = cause instanceof Error ? cause.message : "Could not update T3 Connect access.";
- const traceId = findErrorTraceId(cause);
- console.error("[t3-connect] Could not update T3 Connect", { message, traceId, cause });
- setOperationError(traceId ? `${message} Trace ID: ${traceId}` : message);
- toastManager.add({
- type: "error",
- title: "Could not update T3 Connect",
- description: message,
- data: traceId
- ? {
- secondaryActionProps: {
- children: "Copy trace ID",
- onClick: () => void navigator.clipboard?.writeText(traceId),
- },
- }
- : undefined,
- });
- };
-
- // Older environment servers predate the managedTunnelActive field; for them a
- // link always implies a managed tunnel, so fall back to `linked`.
- const managedTunnelActive =
- primaryCloudLinkState.data?.managedTunnelActive ?? primaryCloudLinkState.data?.linked ?? false;
- const publishAgentActivity = primaryCloudLinkState.data?.publishAgentActivity ?? false;
- const linked = primaryCloudLinkState.data?.linked ?? false;
const disabledReason = !isSignedIn
? "Sign in to T3 Connect to manage this environment."
: !canManageRelay
@@ -1681,86 +1574,6 @@ function ConfiguredCloudLinkRow({ canManageRelay }: { readonly canManageRelay: b
: null;
const isBusy = isUpdating || isUpdatingPreference;
- // T3 Connect (managed tunnel) and publishing are independent capabilities
- // backed by a single relay link. Reconcile the whole desired state: unlink
- // when neither is wanted, otherwise (re)link with the mode the managed-tunnel
- // bit implies and set the publish preference. Re-linking only happens when the
- // managed-tunnel mode actually changes, so flipping publish alone is cheap.
- const reconcileCloudState = async (desired: {
- readonly managedTunnel: boolean;
- readonly publish: boolean;
- }): Promise<boolean> => {
- setOperationError(null);
- const target = primaryCloudLinkState.target;
- if (!target) {
- reportUpdateFailure(new Error("Local environment is not ready yet."));
- return false;
- }
- const tokenResult = await settlePromise(() => getToken(resolveRelayClerkTokenOptions()));
- if (tokenResult._tag === "Failure") {
- reportUpdateFailure(squashAtomCommandFailure(tokenResult));
- return false;
- }
- const clerkToken = tokenResult.value;
- const wantsLink = desired.managedTunnel || desired.publish;
-
- // A failure after this point may follow a partially applied mutation (e.g.
- // the link succeeded but the preference update did not), so every exit —
- // success or failure — refreshes the rendered state to whatever the server
- // actually holds now.
- if (!wantsLink) {
- const unlinkResult = await unlinkPrimaryEnvironment({
- target,
- clerkToken: clerkToken ?? null,
- });
- if (unlinkResult._tag === "Failure") {
- if (!isAtomCommandInterrupted(unlinkResult)) {
- reportUpdateFailure(squashAtomCommandFailure(unlinkResult));
- }
- primaryCloudLinkState.refresh();
- return false;
- }
- } else {
- if (!clerkToken) {
- reportUpdateFailure(new Error("Sign in to T3 Connect before enabling this."));
- return false;
- }
- if (!linked || managedTunnelActive !== desired.managedTunnel) {
- const linkResult = await linkPrimaryEnvironment({
- target,
- clerkToken,
- mode: desired.managedTunnel ? "managed" : "publish_only",
- });
- if (linkResult._tag === "Failure") {
- if (!isAtomCommandInterrupted(linkResult)) {
- reportUpdateFailure(squashAtomCommandFailure(linkResult));
- }
- primaryCloudLinkState.refresh();
- return false;
- }
- }
- const prefResult = await updatePrimaryEnvironmentPreferences({
- target,
- publishAgentActivity: desired.publish,
- });
- if (prefResult._tag === "Failure") {
- if (!isAtomCommandInterrupted(prefResult)) {
- reportUpdateFailure(squashAtomCommandFailure(prefResult));
- }
- primaryCloudLinkState.refresh();
- return false;
- }
- }
-
- primaryCloudLinkState.refresh();
- const refreshResult = await refreshRelayEnvironments();
- if (refreshResult._tag === "Failure" && !isAtomCommandInterrupted(refreshResult)) {
- reportUpdateFailure(squashAtomCommandFailure(refreshResult));
- return false;
- }
- return true;
- };
-
const updateManagedTunnel = async (enabled: boolean) => {
setIsUpdating(true);
const ok = await reconcileCloudState({ managedTunnel: enabled, publish: publishAgentActivity });
@@ -1857,163 +1670,6 @@ function EmptyRemoteEnvironments({ cloudEnabled = true }: { readonly cloudEnable
);
}
-function RemoteEnvironmentRowsSkeleton() {
- return (
- <div className={ITEM_ROW_CLASSNAME}>
- <div className={ITEM_ROW_INNER_CLASSNAME}>
- <div className="min-w-0 flex-1 space-y-2">
- <Skeleton className="h-4 w-32 rounded-full" />
- <Skeleton className="h-3 w-20 rounded-full" />
- </div>
- <Skeleton className="h-7 w-16 rounded-md" />
- </div>
- </div>
- );
-}
-
-function ConfiguredCloudRemoteEnvironmentRows({
- primaryEnvironmentId,
- savedEnvironmentIds,
-}: {
- readonly primaryEnvironmentId: EnvironmentId | null;
- readonly savedEnvironmentIds: ReadonlyArray<EnvironmentId>;
-}) {
- const environmentsState = useRelayEnvironmentDiscovery();
- const registerEnvironment = useAtomCommand(environmentCatalog.register, {
- reportFailure: false,
- });
- const refreshRelayEnvironments = useAtomCommand(relayEnvironmentDiscovery.refresh, {
- reportFailure: false,
- });
- const connectRelayEnvironment = useCallback(
- (environment: RelayClientEnvironmentRecord) =>
- registerEnvironment(
- new RelayConnectionRegistration({
- target: new RelayConnectionTarget({
- environmentId: environment.environmentId,
- label: environment.label,
- }),
- }),
- ),
- [registerEnvironment],
- );
- const [connectingEnvironmentId, setConnectingEnvironmentId] = useState<EnvironmentId | null>(
- null,
- );
- const savedIds = useMemo(() => new Set(savedEnvironmentIds), [savedEnvironmentIds]);
-
- useEffect(() => {
- void refreshRelayEnvironments();
- }, [refreshRelayEnvironments]);
-
- const connectEnvironment = async (environment: RelayClientEnvironmentRecord) => {
- setConnectingEnvironmentId(environment.environmentId);
- const result = await connectRelayEnvironment(environment);
- setConnectingEnvironmentId(null);
- if (result._tag === "Success") {
- toastManager.add({
- type: "success",
- title: "Environment connected",
- description: `${environment.label} is available through T3 Connect.`,
- });
- return;
- }
- if (isAtomCommandInterrupted(result)) {
- return;
- }
- const cause = squashAtomCommandFailure(result);
- const message =
- cause instanceof Error ? cause.message : "Could not connect the T3 Connect environment.";
- const traceId = findErrorTraceId(cause);
- console.error("[t3-connect] Could not connect environment", { message, traceId, cause });
- toastManager.add({
- type: "error",
- title: "Could not connect environment",
- description: message,
- data: traceId
- ? {
- secondaryActionProps: {
- children: "Copy trace ID",
- onClick: () => void navigator.clipboard?.writeText(traceId),
- },
- }
- : undefined,
- });
- };
-
- const connectableEnvironments = [...environmentsState.environments.values()].filter(
- ({ environment }) =>
- environment.environmentId !== primaryEnvironmentId &&
- !savedIds.has(environment.environmentId),
- );
-
- if (
- savedEnvironmentIds.length === 0 &&
- environmentsState.refreshing &&
- environmentsState.environments.size === 0
- ) {
- return <RemoteEnvironmentRowsSkeleton />;
- }
-
- if (savedEnvironmentIds.length === 0 && connectableEnvironments.length === 0) {
- return <EmptyRemoteEnvironments />;
- }
-
- return connectableEnvironments.map(({ environment, availability, error }) => (
- <div key={environment.environmentId} className={ITEM_ROW_CLASSNAME}>
- <div className={ITEM_ROW_INNER_CLASSNAME}>
- <div className="min-w-0">
- <div className="flex items-center gap-2">
- <ConnectionStatusDot
- dotClassName={
- availability === "online"
- ? "bg-success"
- : availability === "error"
- ? "bg-destructive"
- : availability === "checking"
- ? "bg-warning"
- : "bg-muted-foreground/35"
- }
- pingClassName={availability === "checking" ? "bg-warning/60 duration-2000" : null}
- tooltipText={
- availability === "online"
- ? "Relay online"
- : availability === "offline"
- ? "Relay offline"
- : availability === "checking"
- ? "Checking relay status"
- : (Option.getOrNull(error)?.message ?? "Relay status unavailable")
- }
- />
- <p className="truncate text-sm font-medium">{environment.label}</p>
- </div>
- <p
- className={cn(
- "mt-1 truncate text-xs",
- availability === "error" ? "text-destructive" : "text-muted-foreground",
- )}
- >
- {availability === "online"
- ? "Available · Relay online"
- : availability === "offline"
- ? "Available · Relay offline"
- : availability === "checking"
- ? "Available · Checking relay status…"
- : (Option.getOrNull(error)?.message ?? "Available · Relay status unavailable")}
- </p>
- </div>
- <Button
- size="sm"
- disabled={connectingEnvironmentId !== null}
- onClick={() => void connectEnvironment(environment)}
- >
- {connectingEnvironmentId === environment.environmentId ? "Connecting…" : "Connect"}
- </Button>
- </div>
- </div>
- ));
-}
-
function CloudRemoteEnvironmentRows({
primaryEnvironmentId,
savedEnvironmentIds,
@@ -2022,9 +1678,10 @@ function CloudRemoteEnvironmentRows({
readonly savedEnvironmentIds: ReadonlyArray<EnvironmentId>;
}) {
return hasCloudPublicConfig() ? (
- <ConfiguredCloudRemoteEnvironmentRows
+ <CloudEnvironmentConnectRows
primaryEnvironmentId={primaryEnvironmentId}
savedEnvironmentIds={savedEnvironmentIds}
+ empty={<EmptyRemoteEnvironments />}
/>
) : savedEnvironmentIds.length === 0 ? (
<EmptyRemoteEnvironments cloudEnabled={false} />
diff --git a/apps/web/src/components/settings/itemRows.ts b/apps/web/src/components/settings/itemRows.ts
new file mode 100644
index 000000000..df0f1f7c2
--- /dev/null
+++ b/apps/web/src/components/settings/itemRows.ts
@@ -0,0 +1,5 @@
+/** Direct row in the card – same pattern as the Provider / ACP-agent list rows. */
+export const ITEM_ROW_CLASSNAME = "border-t border-border/60 px-4 py-4 first:border-t-0 sm:px-5";
+
+export const ITEM_ROW_INNER_CLASSNAME =
+ "flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between";
diff --git a/apps/web/src/connection/platform.ts b/apps/web/src/connection/platform.ts
index f74465048..56d25fa14 100644
--- a/apps/web/src/connection/platform.ts
+++ b/apps/web/src/connection/platform.ts
@@ -182,7 +182,7 @@ const capabilitiesLayer = Layer.effectContext(
if (session === null) {
return yield* new ConnectionBlockedError({
reason: "authentication",
- detail: "Sign in to T3 Cloud to connect this environment.",
+ detail: "Sign in to T3 Connect to connect this environment.",
});
}
const token = yield* session.readClerkToken().pipe(
@@ -197,7 +197,7 @@ const capabilitiesLayer = Layer.effectContext(
if (token === null) {
return yield* new ConnectionBlockedError({
reason: "authentication",
- detail: "The T3 Cloud session is unavailable.",
+ detail: "The T3 Connect session is unavailable.",
});
}
return token;
diff --git a/apps/web/src/routes/__root.tsx b/apps/web/src/routes/__root.tsx
index 36de3b957..69739ce45 100644
--- a/apps/web/src/routes/__root.tsx
+++ b/apps/web/src/routes/__root.tsx
@@ -14,6 +14,7 @@ import { APP_BASE_NAME, APP_DISPLAY_NAME, APP_STAGE_LABEL } from "../branding";
import { resolveServerBackedAppDisplayName } from "../branding.logic";
import { AppSidebarLayout } from "../components/AppSidebarLayout";
import { CommandPalette } from "../components/CommandPalette";
+import { ConnectOnboardingDialog } from "../components/cloud/ConnectOnboardingDialog";
import { RelayClientInstallDialog } from "../components/cloud/RelayClientInstallDialog";
import { SshPasswordPromptDialog } from "../components/desktop/SshPasswordPromptDialog";
import { ProviderUpdateLaunchNotification } from "../components/ProviderUpdateLaunchNotification";
@@ -128,6 +129,7 @@ function RootRouteView() {
<DocumentTitleSync />
{primaryEnvironmentAuthenticated ? <AuthenticatedTracingBootstrap /> : null}
<RelayClientInstallDialog />
+ <ConnectOnboardingDialog />
<SshPasswordPromptDialog />
<SlowRpcRequestToastCoordinator />
<HostedStaticEnvironmentBootstrap />
diff --git a/packages/client-runtime/src/relay/discovery.test.ts b/packages/client-runtime/src/relay/discovery.test.ts
index 66c27b867..8cb963000 100644
--- a/packages/client-runtime/src/relay/discovery.test.ts
+++ b/packages/client-runtime/src/relay/discovery.test.ts
@@ -342,6 +342,55 @@ describe("RelayEnvironmentDiscovery", () => {
}),
);
+ it.effect("refreshes proactively when credentials change before any manual refresh", () =>
+ Effect.gen(function* () {
+ const harness = yield* makeHarness();
+ yield* Effect.gen(function* () {
+ const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
+ const requests = yield* Ref.get(harness.statusRequests);
+ for (const environment of environments) {
+ yield* Deferred.succeed(
+ requests.get(environment.environmentId)!,
+ status(environment, "online"),
+ );
+ }
+
+ // Let the scoped wakeup subscription start before emitting, mirroring
+ // a real sign-in which always happens long after service start.
+ yield* Effect.yieldNow;
+
+ // Sign-in activates the session and emits credentials-changed; the
+ // list must populate without any screen having asked for a refresh.
+ yield* harness.wake("credentials-changed");
+ const populated = yield* SubscriptionRef.changes(discovery.state).pipe(
+ Stream.filter(
+ (state) => state.environments.size === environments.length && !state.refreshing,
+ ),
+ Stream.runHead,
+ Effect.map(Option.getOrThrow),
+ );
+ expect(Option.isNone(populated.error)).toBe(true);
+ expect(yield* Ref.get(harness.listCalls)).toBe(1);
+ }).pipe(Effect.provide(harness.layer), Effect.scoped);
+ }),
+ );
+
+ it.effect("settles to a clean empty state when refreshed while signed out", () =>
+ Effect.gen(function* () {
+ const harness = yield* makeHarness();
+ yield* Effect.gen(function* () {
+ const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery;
+ yield* Ref.set(harness.clerkToken, null);
+ yield* discovery.refresh;
+
+ const state = yield* SubscriptionRef.get(discovery.state);
+ expect(state.environments.size).toBe(0);
+ expect(state.refreshing).toBe(false);
+ expect(Option.isNone(state.error)).toBe(true);
+ }).pipe(Effect.provide(harness.layer));
+ }),
+ );
+
it.effect("does not republish stale rows after sign-out invalidates an in-flight refresh", () =>
Effect.gen(function* () {
const harness = yield* makeHarness();
diff --git a/packages/client-runtime/src/relay/discovery.ts b/packages/client-runtime/src/relay/discovery.ts
index 8cbadea1c..855bb2654 100644
--- a/packages/client-runtime/src/relay/discovery.ts
+++ b/packages/client-runtime/src/relay/discovery.ts
@@ -222,7 +222,27 @@ export const make = Effect.fn("RelayEnvironmentDiscovery.make")(function* () {
error: Option.none(),
});
- const clerkToken = yield* session.clerkToken;
+ // Signed out is the idle state, not a failure: the proactive refresh on
+ // credentials-changed also runs on sign-out and must settle back to a
+ // clean empty list. Only the session-level "no credentials" error is
+ // benign — relay-side auth failures (expired/invalid tokens) happen
+ // after this point and must surface as errors.
+ const tokenResult = yield* Effect.result(session.clerkToken);
+ if (tokenResult._tag === "Failure") {
+ const failure = tokenResult.failure;
+ if (failure._tag === "ConnectionBlockedError" && failure.reason === "authentication") {
+ if ((yield* Ref.get(accountGeneration)) !== generation) {
+ return;
+ }
+ yield* SubscriptionRef.update(state, (current) => ({
+ ...current,
+ refreshing: false,
+ }));
+ return;
+ }
+ return yield* Effect.fail(failure);
+ }
+ const clerkToken = tokenResult.success;
if ((yield* Ref.get(accountGeneration)) !== generation) {
return;
}
@@ -311,11 +331,12 @@ export const make = Effect.fn("RelayEnvironmentDiscovery.make")(function* () {
yield* Ref.update(accountGeneration, (current) => current + 1);
yield* Ref.set(activeAccountId, Option.none());
yield* Ref.set(offlineReportFingerprints, new Map());
- const shouldRefresh = yield* Ref.get(hasRefreshed);
yield* SubscriptionRef.set(state, EMPTY_RELAY_ENVIRONMENT_DISCOVERY_STATE);
- if (shouldRefresh) {
- yield* refresh.pipe(Effect.forkScoped);
- }
+ // Refresh proactively — this wakeup fires when a session activates
+ // (sign-in or cold start), and the list should be populated before
+ // any screen asks for it. A signed-out refresh settles back to the
+ // clean empty state.
+ yield* refresh.pipe(Effect.forkScoped);
})
: Effect.void,
),
diff --git a/packages/client-runtime/src/relay/managedRelayState.ts b/packages/client-runtime/src/relay/managedRelayState.ts
index ec6a0710d..1d12c90aa 100644
--- a/packages/client-runtime/src/relay/managedRelayState.ts
+++ b/packages/client-runtime/src/relay/managedRelayState.ts
@@ -123,7 +123,7 @@ export function createManagedRelaySession(input: ManagedRelaySessionInput): Mana
try: () => readCachedClerkToken(nowMillis),
catch: (cause) =>
new ManagedRelaySessionError({
- message: "Could not obtain the T3 Cloud session token.",
+ message: "Could not obtain the T3 Connect session token.",
cause,
}),
});
@@ -181,7 +181,7 @@ function readSessionClerkToken(
? Effect.succeed(token)
: Effect.fail(
new ManagedRelaySessionError({
- message: "The T3 Cloud session token is unavailable.",
+ message: "The T3 Connect session token is unavailable.",
}),
),
),
@@ -226,7 +226,7 @@ function requireClerkToken(
if (!session || session.accountId !== accountId) {
return Effect.fail(
new ManagedRelaySessionError({
- message: "Sign in to T3 Cloud before loading relay data.",
+ message: "Sign in to T3 Connect before loading relay data.",
}),
);
}
@@ -296,7 +296,7 @@ export function readManagedRelaySnapshotState<A>(
let errorTraceId: string | null = null;
if (result._tag === "Failure") {
const cause = Cause.squash(result.cause);
- error = cause instanceof Error ? cause.message : "Could not load T3 Cloud data.";
+ error = cause instanceof Error ? cause.message : "Could not load T3 Connect data.";
errorTraceId = findErrorTraceId(cause);
}
return {