@devries-cameron20 / t3code-1 / commits / 94bce7f124
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

refactor(web): composer mode controls and footer actions live in ComposerFooterControls (#22720)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Oct 21, 2026 at 01:24 UTC 94bce7f1242cbc1919cd37f5e7af065b8f3dd1ff
2 files changed +230 -226
apps/web/src/components/chat/ChatComposer.tsx
+3 -226
@@ -105,7 +105,6 @@ import {
105 makeComposerMentionDragHandlers,
106 } from "./composerMentionDrag";
107 import {
108 - useComposerMenuProps,
108 isInsideCollapsedComposerControls,
109 isInsideRestingComposerControlScope,
110 } from "./composerEventScope";
@@ -134,7 +133,6 @@ import {
133 } from "../../promptStashStore";
134 import { ComposerStashBadge } from "./ComposerStashBadge";
135 import { ComposerStashMenu } from "./ComposerStashMenu";
137 -import { useComposerMenuState } from "./useComposerMenuState";
136 import { useComposerTriggerState } from "./useComposerTriggerState";
137 import { useComposerFocusState } from "./useComposerFocusState";
138 import { useComposerMultilinePrompt } from "./useComposerMultilinePrompt";
@@ -288,15 +286,11 @@ import {
286 ComposerRestingImagePreviews,
287 } from "./ComposerAttachmentStrip";
288 import { ComposerPrimaryActions } from "./ComposerPrimaryActions";
289 +import { ComposerFooterModeControls, ComposerFooterPrimaryActions } from "./ComposerFooterControls";
290 import { ComposerPendingApprovalPanel } from "./ComposerPendingApprovalPanel";
291 import { ComposerPendingUserInputPanel } from "./ComposerPendingUserInputPanel";
292 import { ComposerPlanFollowUpBanner } from "./ComposerPlanFollowUpBanner";
294 -import {
295 - ComposerControl,
296 - ComposerControlIcon,
297 - ComposerControlSeparator,
298 - ComposerSelectControl,
299 -} from "./ComposerControl";
293 +import { ComposerControl, ComposerControlSeparator } from "./ComposerControl";
294 import { resolveComposerMenuActiveItemId } from "./composerMenuHighlight";
295 import { buildPullRequestReferenceContext } from "../pullRequest/pullRequestDetail.logic";
296 import {
@@ -314,7 +308,6 @@ import {
308 renderProviderTraitsMenuContent,
309 renderProviderTraitsPicker,
310 } from "./composerProviderState";
317 -import { ContextWindowMeter, ContextWindowMeterPlaceholder } from "./ContextWindowMeter";
311 import {
312 providerSupportsManualCompaction,
313 resolveContextWindowModelDisplayName,
@@ -973,17 +966,9 @@ function ComposerCommandMenuLayer(props: { anchor: HTMLElement | null; children:
966 );
967 }
968 import { Button } from "../ui/button";
976 -import { Select, SelectItem, SelectPopup, SelectValue } from "../ui/select";
969 import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
970 import { toastManager } from "../ui/toast";
979 -import {
980 - BotIcon,
981 - CircleAlertIcon,
982 - PaperclipIcon,
983 - PencilRulerIcon,
984 - PlayIcon,
985 - ShieldIcon,
986 -} from "lucide-react";
971 +import { CircleAlertIcon, PaperclipIcon, PlayIcon, ShieldIcon } from "lucide-react";
972 import { proposedPlanTitle } from "@t3tools/shared/proposedPlanText";
973 import { hasProviderSetup } from "./ProviderStatusBanner";
974 import {
@@ -1144,215 +1129,7 @@ function useRestingComposerControlsLayout(host: HTMLDivElement | null, useContro
1129 };
1130 }
1131
1147 -type RuntimeModeOption = { mode: RuntimeMode } & (typeof runtimeModeConfig)[RuntimeMode];
1132 const runtimeModeOptions = runtimeModes.map((mode) => ({ mode, ...runtimeModeConfig[mode] }));
1149 -const supervisedRuntimeModeOption = {
1150 - mode: "approval-required" as const,
1151 - ...runtimeModeConfig["approval-required"],
1152 -};
1153 -const ComposerFooterModeControls = memo(function ComposerFooterModeControls(props: {
1154 - showInteractionModeToggle: boolean;
1155 - interactionMode: ProviderInteractionMode;
1156 - runtimeMode: RuntimeMode;
1157 - runtimeModeOptions: ReadonlyArray<RuntimeModeOption>;
1158 - size?: "sm" | "xs";
1159 - hidden?: boolean;
1160 - onToggleInteractionMode: () => void;
1161 - onRuntimeModeChange: (mode: RuntimeMode) => void;
1162 -}) {
1163 - const size = props.size ?? "sm";
1164 - const composerFloatingLayerProps = useComposerMenuProps();
1165 - const [open, setOpen] = useComposerMenuState(props.hidden);
1166 - const runtimeModeOption =
1167 - props.runtimeModeOptions.find((option) => option.mode === props.runtimeMode) ??
1168 - supervisedRuntimeModeOption;
1169 - const RuntimeModeIcon = runtimeModeOption.icon;
1170 - const interactionModeTooltip =
1171 - props.interactionMode === "plan"
1172 - ? "Plan mode — click to return to normal build mode"
1173 - : "Default mode — click to enter plan mode";
1174 -
1175 - const interactionModeToggle = props.showInteractionModeToggle ? (
1176 - <>
1177 - <ComposerControlSeparator size={size} />
1178 - <Tooltip>
1179 - <TooltipTrigger
1180 - render={
1181 - <ComposerControl
1182 - size={size}
1183 - className="shrink-0 whitespace-nowrap"
1184 - aria-pressed={props.interactionMode === "plan"}
1185 - type="button"
1186 - onClick={props.onToggleInteractionMode}
1187 - aria-label={interactionModeTooltip}
1188 - />
1189 - }
1190 - >
1191 - {props.interactionMode === "plan" ? (
1192 - <ComposerControlIcon
1193 - icon={PencilRulerIcon}
1194 - size={size}
1195 - className="text-current opacity-100"
1196 - />
1197 - ) : (
1198 - <ComposerControlIcon
1199 - icon={BotIcon}
1200 - size={size}
1201 - opticalSize={size === "xs" ? "default" : "large"}
1202 - />
1203 - )}
1204 - <span data-composer-control-label className="sr-only sm:not-sr-only">
1205 - {props.interactionMode === "plan" ? "Plan" : "Build"}
1206 - </span>
1207 - </TooltipTrigger>
1208 - <TooltipPopup side="top">{interactionModeTooltip}</TooltipPopup>
1209 - </Tooltip>
1210 - </>
1211 - ) : null;
1212 -
1213 - return (
1214 - <>
1215 - <ComposerControlSeparator size={size} />
1216 -
1217 - <Tooltip>
1218 - <Select
1219 - open={open}
1220 - onOpenChange={setOpen}
1221 - value={props.runtimeMode}
1222 - onValueChange={(value) => props.onRuntimeModeChange(value!)}
1223 - >
1224 - <TooltipTrigger
1225 - render={
1226 - <ComposerSelectControl
1227 - data-composer-shortcut="composer.mode"
1228 - size={size}
1229 - aria-label="Runtime mode"
1230 - />
1231 - }
1232 - >
1233 - <ComposerControlIcon icon={RuntimeModeIcon} size={size} />
1234 - <SelectValue data-composer-control-label>{runtimeModeOption.label}</SelectValue>
1235 - </TooltipTrigger>
1236 - <SelectPopup alignItemWithTrigger={false} {...composerFloatingLayerProps}>
1237 - {props.runtimeModeOptions.map((option) => {
1238 - const OptionIcon = option.icon;
1239 - return (
1240 - <SelectItem
1241 - key={option.mode}
1242 - value={option.mode}
1243 - hideIndicator
1244 - className="min-w-64"
1245 - >
1246 - <div className="flex min-w-0 items-center gap-3">
1247 - <div className="grid min-w-0 flex-1 gap-0.5">
1248 - <span className="inline-flex items-center gap-1.5 font-medium text-foreground">
1249 - <OptionIcon className="size-3.5 shrink-0 text-muted-foreground" />
1250 - {option.label}
1251 - </span>
1252 - <span className="text-muted-foreground text-xs leading-4">
1253 - {option.description}
1254 - </span>
1255 - </div>
1256 - </div>
1257 - </SelectItem>
1258 - );
1259 - })}
1260 - </SelectPopup>
1261 - </Select>
1262 - <TooltipPopup side="top">{runtimeModeOption.description}</TooltipPopup>
1263 - </Tooltip>
1264 -
1265 - {interactionModeToggle}
1266 - </>
1267 - );
1268 -});
1269 -
1270 -const ComposerFooterPrimaryActions = memo(function ComposerFooterPrimaryActions(props: {
1271 - compact: boolean;
1272 - canOperateThread: boolean;
1273 - activeContextWindow: ContextWindowSnapshot | null;
1274 - reserveContextWindowMeter: boolean;
1275 - activeThreadModelDisplayName: string | null;
1276 - isPreparingWorktree: boolean;
1277 - pendingAction: {
1278 - questionIndex: number;
1279 - isLastQuestion: boolean;
1280 - canAdvance: boolean;
1281 - isResponding: boolean;
1282 - isComplete: boolean;
1283 - } | null;
1284 - isRunning: boolean;
1285 - canInterrupt: boolean;
1286 - followUpBehavior: "queue" | "steer";
1287 - canSteer: boolean;
1288 - alternateShortcutLabel: string | null;
1289 - showPlanFollowUpPrompt: boolean;
1290 - promptHasText: boolean;
1291 - isSendBusy: boolean;
1292 - sendDisabledReason: string | null;
1293 - isConnecting: boolean;
1294 - isEnvironmentUnavailable: boolean;
1295 - hasSendableContent: boolean;
1296 - canResume: boolean;
1297 - preserveComposerFocusOnPointerDown?: boolean;
1298 - isEditingQueuedMessage: boolean;
1299 - onSubmitMessage: React.MouseEventHandler<HTMLButtonElement>;
1300 - onResume: () => void;
1301 - onPreviousPendingQuestion: () => void;
1302 - onInterrupt: () => void;
1303 - onImplementPlanInNewThread: () => void;
1304 - onCompactContext?: (() => void) | undefined;
1305 - compactDisabled: boolean;
1306 - compactDisabledReason: string | null;
1307 - compactBeforeSendTokens: number | null;
1308 - keepFullHistory: boolean;
1309 - onToggleKeepFullHistory: () => void;
1310 -}) {
1311 - return (
1312 - <>
1313 - {props.activeContextWindow ? (
1314 - <ContextWindowMeter
1315 - usage={props.activeContextWindow}
1316 - modelDisplayName={props.activeThreadModelDisplayName}
1317 - onCompact={props.onCompactContext}
1318 - compactDisabled={props.compactDisabled}
1319 - compactDisabledReason={props.compactDisabledReason}
1320 - />
1321 - ) : props.reserveContextWindowMeter ? (
1322 - <ContextWindowMeterPlaceholder />
1323 - ) : null}
1324 - <ComposerPrimaryActions
1325 - compact={props.compact}
1326 - canOperateThread={props.canOperateThread}
1327 - pendingAction={props.pendingAction}
1328 - isRunning={props.isRunning}
1329 - canInterrupt={props.canInterrupt}
1330 - followUpBehavior={props.followUpBehavior}
1331 - canSteer={props.canSteer}
1332 - alternateShortcutLabel={props.alternateShortcutLabel}
1333 - showPlanFollowUpPrompt={props.showPlanFollowUpPrompt}
1334 - promptHasText={props.promptHasText}
1335 - isSendBusy={props.isSendBusy}
1336 - sendDisabledReason={props.sendDisabledReason}
1337 - isConnecting={props.isConnecting}
1338 - isEnvironmentUnavailable={props.isEnvironmentUnavailable}
1339 - isPreparingWorktree={props.isPreparingWorktree}
1340 - hasSendableContent={props.hasSendableContent}
1341 - canResume={props.canResume}
1342 - preserveComposerFocusOnPointerDown={props.preserveComposerFocusOnPointerDown ?? false}
1343 - isEditingQueuedMessage={props.isEditingQueuedMessage}
1344 - onSubmitMessage={props.onSubmitMessage}
1345 - onResume={props.onResume}
1346 - onPreviousPendingQuestion={props.onPreviousPendingQuestion}
1347 - onInterrupt={props.onInterrupt}
1348 - onImplementPlanInNewThread={props.onImplementPlanInNewThread}
1349 - compactBeforeSendTokens={props.compactBeforeSendTokens}
1350 - keepFullHistory={props.keepFullHistory}
1351 - onToggleKeepFullHistory={props.onToggleKeepFullHistory}
1352 - />
1353 - </>
1354 - );
1355 -});
1133
1134 export interface ChatComposerHandle {
1135 focusAtEnd: () => void;
apps/web/src/components/chat/ComposerFooterControls.tsx new
+227
@@ -0,0 +1,227 @@
1 +import type { ProviderInteractionMode, RuntimeMode } from "@t3tools/contracts";
2 +import { BotIcon, PencilRulerIcon } from "lucide-react";
3 +import { memo } from "react";
4 +
5 +import type { ContextWindowSnapshot } from "../../lib/contextWindow";
6 +import { Select, SelectItem, SelectPopup, SelectValue } from "../ui/select";
7 +import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
8 +import {
9 + ComposerControl,
10 + ComposerControlIcon,
11 + ComposerControlSeparator,
12 + ComposerSelectControl,
13 +} from "./ComposerControl";
14 +import { useComposerMenuProps } from "./composerEventScope";
15 +import { ComposerPrimaryActions } from "./ComposerPrimaryActions";
16 +import { ContextWindowMeter, ContextWindowMeterPlaceholder } from "./ContextWindowMeter";
17 +import { runtimeModeConfig } from "./runtimeModeConfig";
18 +import { useComposerMenuState } from "./useComposerMenuState";
19 +
20 +export type RuntimeModeOption = { mode: RuntimeMode } & (typeof runtimeModeConfig)[RuntimeMode];
21 +const supervisedRuntimeModeOption = {
22 + mode: "approval-required" as const,
23 + ...runtimeModeConfig["approval-required"],
24 +};
25 +export const ComposerFooterModeControls = memo(function ComposerFooterModeControls(props: {
26 + showInteractionModeToggle: boolean;
27 + interactionMode: ProviderInteractionMode;
28 + runtimeMode: RuntimeMode;
29 + runtimeModeOptions: ReadonlyArray<RuntimeModeOption>;
30 + size?: "sm" | "xs";
31 + hidden?: boolean;
32 + onToggleInteractionMode: () => void;
33 + onRuntimeModeChange: (mode: RuntimeMode) => void;
34 +}) {
35 + const size = props.size ?? "sm";
36 + const composerFloatingLayerProps = useComposerMenuProps();
37 + const [open, setOpen] = useComposerMenuState(props.hidden);
38 + const runtimeModeOption =
39 + props.runtimeModeOptions.find((option) => option.mode === props.runtimeMode) ??
40 + supervisedRuntimeModeOption;
41 + const RuntimeModeIcon = runtimeModeOption.icon;
42 + const interactionModeTooltip =
43 + props.interactionMode === "plan"
44 + ? "Plan mode — click to return to normal build mode"
45 + : "Default mode — click to enter plan mode";
46 +
47 + const interactionModeToggle = props.showInteractionModeToggle ? (
48 + <>
49 + <ComposerControlSeparator size={size} />
50 + <Tooltip>
51 + <TooltipTrigger
52 + render={
53 + <ComposerControl
54 + size={size}
55 + className="shrink-0 whitespace-nowrap"
56 + aria-pressed={props.interactionMode === "plan"}
57 + type="button"
58 + onClick={props.onToggleInteractionMode}
59 + aria-label={interactionModeTooltip}
60 + />
61 + }
62 + >
63 + {props.interactionMode === "plan" ? (
64 + <ComposerControlIcon
65 + icon={PencilRulerIcon}
66 + size={size}
67 + className="text-current opacity-100"
68 + />
69 + ) : (
70 + <ComposerControlIcon
71 + icon={BotIcon}
72 + size={size}
73 + opticalSize={size === "xs" ? "default" : "large"}
74 + />
75 + )}
76 + <span data-composer-control-label className="sr-only sm:not-sr-only">
77 + {props.interactionMode === "plan" ? "Plan" : "Build"}
78 + </span>
79 + </TooltipTrigger>
80 + <TooltipPopup side="top">{interactionModeTooltip}</TooltipPopup>
81 + </Tooltip>
82 + </>
83 + ) : null;
84 +
85 + return (
86 + <>
87 + <ComposerControlSeparator size={size} />
88 +
89 + <Tooltip>
90 + <Select
91 + open={open}
92 + onOpenChange={setOpen}
93 + value={props.runtimeMode}
94 + onValueChange={(value) => props.onRuntimeModeChange(value!)}
95 + >
96 + <TooltipTrigger
97 + render={
98 + <ComposerSelectControl
99 + data-composer-shortcut="composer.mode"
100 + size={size}
101 + aria-label="Runtime mode"
102 + />
103 + }
104 + >
105 + <ComposerControlIcon icon={RuntimeModeIcon} size={size} />
106 + <SelectValue data-composer-control-label>{runtimeModeOption.label}</SelectValue>
107 + </TooltipTrigger>
108 + <SelectPopup alignItemWithTrigger={false} {...composerFloatingLayerProps}>
109 + {props.runtimeModeOptions.map((option) => {
110 + const OptionIcon = option.icon;
111 + return (
112 + <SelectItem
113 + key={option.mode}
114 + value={option.mode}
115 + hideIndicator
116 + className="min-w-64"
117 + >
118 + <div className="flex min-w-0 items-center gap-3">
119 + <div className="grid min-w-0 flex-1 gap-0.5">
120 + <span className="inline-flex items-center gap-1.5 font-medium text-foreground">
121 + <OptionIcon className="size-3.5 shrink-0 text-muted-foreground" />
122 + {option.label}
123 + </span>
124 + <span className="text-muted-foreground text-xs leading-4">
125 + {option.description}
126 + </span>
127 + </div>
128 + </div>
129 + </SelectItem>
130 + );
131 + })}
132 + </SelectPopup>
133 + </Select>
134 + <TooltipPopup side="top">{runtimeModeOption.description}</TooltipPopup>
135 + </Tooltip>
136 +
137 + {interactionModeToggle}
138 + </>
139 + );
140 +});
141 +
142 +export const ComposerFooterPrimaryActions = memo(function ComposerFooterPrimaryActions(props: {
143 + compact: boolean;
144 + canOperateThread: boolean;
145 + activeContextWindow: ContextWindowSnapshot | null;
146 + reserveContextWindowMeter: boolean;
147 + activeThreadModelDisplayName: string | null;
148 + isPreparingWorktree: boolean;
149 + pendingAction: {
150 + questionIndex: number;
151 + isLastQuestion: boolean;
152 + canAdvance: boolean;
153 + isResponding: boolean;
154 + isComplete: boolean;
155 + } | null;
156 + isRunning: boolean;
157 + canInterrupt: boolean;
158 + followUpBehavior: "queue" | "steer";
159 + canSteer: boolean;
160 + alternateShortcutLabel: string | null;
161 + showPlanFollowUpPrompt: boolean;
162 + promptHasText: boolean;
163 + isSendBusy: boolean;
164 + sendDisabledReason: string | null;
165 + isConnecting: boolean;
166 + isEnvironmentUnavailable: boolean;
167 + hasSendableContent: boolean;
168 + canResume: boolean;
169 + preserveComposerFocusOnPointerDown?: boolean;
170 + isEditingQueuedMessage: boolean;
171 + onSubmitMessage: React.MouseEventHandler<HTMLButtonElement>;
172 + onResume: () => void;
173 + onPreviousPendingQuestion: () => void;
174 + onInterrupt: () => void;
175 + onImplementPlanInNewThread: () => void;
176 + onCompactContext?: (() => void) | undefined;
177 + compactDisabled: boolean;
178 + compactDisabledReason: string | null;
179 + compactBeforeSendTokens: number | null;
180 + keepFullHistory: boolean;
181 + onToggleKeepFullHistory: () => void;
182 +}) {
183 + return (
184 + <>
185 + {props.activeContextWindow ? (
186 + <ContextWindowMeter
187 + usage={props.activeContextWindow}
188 + modelDisplayName={props.activeThreadModelDisplayName}
189 + onCompact={props.onCompactContext}
190 + compactDisabled={props.compactDisabled}
191 + compactDisabledReason={props.compactDisabledReason}
192 + />
193 + ) : props.reserveContextWindowMeter ? (
194 + <ContextWindowMeterPlaceholder />
195 + ) : null}
196 + <ComposerPrimaryActions
197 + compact={props.compact}
198 + canOperateThread={props.canOperateThread}
199 + pendingAction={props.pendingAction}
200 + isRunning={props.isRunning}
201 + canInterrupt={props.canInterrupt}
202 + followUpBehavior={props.followUpBehavior}
203 + canSteer={props.canSteer}
204 + alternateShortcutLabel={props.alternateShortcutLabel}
205 + showPlanFollowUpPrompt={props.showPlanFollowUpPrompt}
206 + promptHasText={props.promptHasText}
207 + isSendBusy={props.isSendBusy}
208 + sendDisabledReason={props.sendDisabledReason}
209 + isConnecting={props.isConnecting}
210 + isEnvironmentUnavailable={props.isEnvironmentUnavailable}
211 + isPreparingWorktree={props.isPreparingWorktree}
212 + hasSendableContent={props.hasSendableContent}
213 + canResume={props.canResume}
214 + preserveComposerFocusOnPointerDown={props.preserveComposerFocusOnPointerDown ?? false}
215 + isEditingQueuedMessage={props.isEditingQueuedMessage}
216 + onSubmitMessage={props.onSubmitMessage}
217 + onResume={props.onResume}
218 + onPreviousPendingQuestion={props.onPreviousPendingQuestion}
219 + onInterrupt={props.onInterrupt}
220 + onImplementPlanInNewThread={props.onImplementPlanInNewThread}
221 + compactBeforeSendTokens={props.compactBeforeSendTokens}
222 + keepFullHistory={props.keepFullHistory}
223 + onToggleKeepFullHistory={props.onToggleKeepFullHistory}
224 + />
225 + </>
226 + );
227 +});