import { useAtomValue } from "@effect/atom-react";
import { NotificationSettings } from "./NotificationSettings";
import { PRIVACY_POLICY_URL } from "../../legalLinks";
import { CheckIcon } from "lucide-react";
import { Link, useNavigate } from "@tanstack/react-router";
import { useRef, useState } from "react";
import {
type DesktopUpdateChannel,
IDLE_COMPACTION_MODES,
globalIdleCompaction,
managedUpdatesDenial,
managedUpdatesMessage,
ProviderDriverKind,
type ProviderInstanceId,
type SidebarProjectGroupingMode,
} from "@t3tools/contracts";
import {
DEFAULT_UNIFIED_SETTINGS,
type DiffLayout,
MAX_SIDEBAR_AUTO_SETTLE_AFTER_DAYS,
MIN_SIDEBAR_AUTO_SETTLE_AFTER_DAYS,
type ResponseStreamingMode,
type QuitConfirmationMode,
SidebarProjectSortOrder,
} from "@t3tools/contracts/settings";
import { desktopUpdateChannelOf } from "@t3tools/shared/cliRelease";
import { createModelSelection } from "@t3tools/shared/model";
import { resolvePastedPath } from "@t3tools/shared/path";
import * as Equal from "effect/Equal";
import * as Schema from "effect/Schema";
import { APP_VERSION, HOSTED_APP_CHANNEL, HOSTED_APP_CHANNEL_LABEL } from "../../branding";
import { AboutVersionTitle } from "./AboutVersionTitle";
import { CliCommandSettingsRow } from "./CliCommandSettingsRow";
import { MobileAppSettingsRow } from "./MobileAppSettingsRow";
import {
canCheckForUpdate,
getDesktopUpdateButtonTooltip,
getDesktopUpdateDisabledReason,
getDesktopUpdateInstallConfirmationMessage,
isDesktopUpdateButtonDisabled,
resolveDesktopUpdateButtonAction,
} from "../../components/desktopUpdate.logic";
import { ProviderModelPicker } from "../chat/ProviderModelPicker";
import { TraitsPicker } from "../chat/TraitsPicker";
import { isElectron } from "../../env";
import { buildHostedChannelSelectionUrl, type HostedAppChannel } from "../../hostedPairing";
import {
readAppearanceModePreference,
readThemeHalves,
readThemePreference,
useTheme,
} from "../../hooks/useTheme";
import {
useScopedSettings,
useScopedSettingsMixed,
useUpdateScopedSettings,
} from "./useScopedSettings";
import { useScopedModelDisabledReason } from "./useScopedModelAvailability";
import { useOptionalSettingsScope, useSettingsScope } from "./SettingsScopeContext";
import { scopedIdleCompaction } from "./scopedSettings";
import { ProjectDefaultsSettings } from "./ProjectDefaultsSettings";
import { ThreadTitleInstructionsSettings } from "./ThreadTitleInstructionsSettings";
import { SnoozePresetsRow } from "./SnoozePresetsSettings";
import { useDesktopUpdateState } from "../../state/desktopUpdate";
import { managedTelemetryOffMessage, usePrimaryManagedPolicy } from "../../state/managedPolicy";
import {
getCustomModelOptionsByInstance,
resolveAppModelSelectionState,
selectsPlanAgent,
} from "../../modelSelection";
import { providerInstanceEntriesFor } from "../../providerInstances";
import { ensureLocalApi, readLocalApi } from "../../localApi";
import { isMacPlatform } from "../../lib/utils";
import { useEnvironmentProviders, useEnvironments } from "../../state/environments";
import { EMPTY_SERVER_PROVIDERS } from "../../state/server";
import { Button } from "../ui/button";
import { DraftInput } from "../ui/draft-input";
import { Input } from "../ui/input";
import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select";
import { Switch } from "../ui/switch";
import { ScopedSwitch } from "./ScopedSwitch";
import { stackedThreadToast, toastManager } from "../ui/toast";
import { Tooltip, TooltipPopup, TooltipTrigger } from "../ui/tooltip";
import {
getChangedBrowserSettingLabels,
getChangedTypographySettingLabels,
hasChangedBackgroundActivitySettings,
isProjectGroupingEnabled,
projectGroupingModeFromToggle,
readLastEnabledProjectGroupingMode,
rememberEnabledProjectGroupingMode,
} from "./SettingsPanels.logic";
import {
SETTINGS_PICKER_TRIGGER_CLASSNAME,
SettingResetButton,
SettingsPageContainer,
SettingsRow,
SettingsSection,
} from "./settingsLayout";
import { searchableSetting } from "./settingsSearch";
import { BackgroundActivitySettingsRow } from "./BackgroundActivitySettings";
import { AdvancedSettings } from "./AdvancedSettings";
import { PullRequestLinksOpenInAppSetting } from "./IntegrationsSettings";
import { StorageCleanupSections } from "./StorageSettings";
import { UpdateTrackSwitchDialog } from "./UpdateTrackSwitchDialog";
import { environmentIdsKey } from "~/state/environmentAtomList";
import { environmentSessionStatesAtom } from "~/state/session";
import { canUpdateServer } from "../ServerUpdateAction";
import { useUpdateEverythingRun } from "../sidebar/updateEverythingRun";
import { awaitsTrackSwitch, channelSwitchLabel } from "../sidebar/updateEverything.logic";
import { isHostedByThisApp } from "../sidebar/useUpdateEverything";
const RESPONSE_STREAMING_MODE_LABELS: Record<ResponseStreamingMode, string> = {
turn: "Wait for the full response",
paragraph: "Show finished paragraphs",
};
const RESPONSE_STREAMING_MODE_DESCRIPTIONS: Record<ResponseStreamingMode, string> = {
turn: "Text appears once the agent finishes its turn.",
paragraph: "Each paragraph or code block appears as soon as it is complete.",
};
const SIDEBAR_PROJECT_SORT_ORDER_LABELS: Record<SidebarProjectSortOrder, string> = {
updated_at: "Last user message",
created_at: "Created at",
manual: "Manual",
};
const isSidebarProjectSortOrder = Schema.is(SidebarProjectSortOrder);
const TIMESTAMP_FORMAT_LABELS = {
locale: "System default",
"12-hour": "12-hour",
"24-hour": "24-hour",
} as const;
const DIFF_LAYOUT_LABELS: Record<DiffLayout, string> = {
stacked: "Stacked",
split: "Split",
};
const QUIT_CONFIRMATION_MODE_LABELS: Record<QuitConfirmationMode, string> = {
direct: "Direct",
hold: "Hold",
"double-click": "Double press",
};
const DEFAULT_DRIVER_KIND = ProviderDriverKind.make("codex");
function AboutVersionSection() {
const updateState = useDesktopUpdateState();
const [switchChannel, setSwitchChannel] = useState<DesktopUpdateChannel | null>(null);
const [isUpdateActionPending, setIsUpdateActionPending] = useState(false);
const { environments } = useEnvironments();
const sessionStates = useAtomValue(
environmentSessionStatesAtom(
environmentIdsKey(environments.map(({ environmentId }) => environmentId)),
),
);
// A second run would replace the first run's progress and local download.
const updateRun = useUpdateEverythingRun();
const hasDesktopBridge = typeof window !== "undefined" && Boolean(window.desktopBridge);
const selectedUpdateChannel = updateState?.channel ?? "latest";
// The desktop updates this machine, whose policy the primary environment reports.
const primaryPolicy = usePrimaryManagedPolicy();
const updatesDenial = hasDesktopBridge ? managedUpdatesDenial(primaryPolicy) : undefined;
const nightlyDeniedBy =
hasDesktopBridge && primaryPolicy?.limits?.updates?.allowNightly === false
? primaryPolicy.organization
: undefined;
const selectedHostedAppChannel = hasDesktopBridge ? null : HOSTED_APP_CHANNEL;
// A switch that failed part way leaves this app or a server on the other track.
// With its updater off, a switch cannot move this app, so it is not counted.
const appOffTrack =
updateState?.enabled !== false && desktopUpdateChannelOf(APP_VERSION) !== selectedUpdateChannel;
const unswitchedMachines =
(appOffTrack ? 1 : 0) +
environments.filter(
(environment, index) =>
environment.connection.phase === "connected" &&
canUpdateServer(sessionStates[index]!) &&
awaitsTrackSwitch(
{
serverConfig: environment.serverConfig,
hostedByThisApp: isHostedByThisApp(environment),
},
selectedUpdateChannel,
),
).length;
const handleButtonClick = async () => {
const bridge = window.desktopBridge;
if (!bridge) return;
const action = updateState ? resolveDesktopUpdateButtonAction(updateState) : "none";
if (action === "download") {
void bridge.downloadUpdate().catch((error: unknown) => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Could not download update",
description: error instanceof Error ? error.message : "Download failed.",
}),
);
});
return;
}
if (action === "install") {
if (isUpdateActionPending) return;
setIsUpdateActionPending(true);
let confirmed = false;
try {
confirmed = await ensureLocalApi().dialogs.confirm(
getDesktopUpdateInstallConfirmationMessage(
updateState ?? { availableVersion: null, downloadedVersion: null },
),
);
} catch (error) {
setIsUpdateActionPending(false);
toastManager.add(
stackedThreadToast({
type: "error",
title: "Could not confirm update",
description: error instanceof Error ? error.message : "Update confirmation failed.",
}),
);
return;
}
if (!confirmed) {
setIsUpdateActionPending(false);
return;
}
void bridge
.installUpdate()
.catch((error: unknown) => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Could not install update",
description: error instanceof Error ? error.message : "Install failed.",
}),
);
})
.finally(() => setIsUpdateActionPending(false));
return;
}
if (typeof bridge.checkForUpdate !== "function") return;
void bridge
.checkForUpdate()
.then((result) => {
if (!result.checked) {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Could not check for updates",
description:
updatesDenial ??
result.state.message ??
"Automatic updates are not available in this build.",
}),
);
}
})
.catch((error: unknown) => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Could not check for updates",
description: error instanceof Error ? error.message : "Update check failed.",
}),
);
});
};
const action = updateState ? resolveDesktopUpdateButtonAction(updateState) : "none";
const buttonTooltip = updateState ? getDesktopUpdateButtonTooltip(updateState) : null;
const buttonDisabled =
action === "none"
? !canCheckForUpdate(updateState)
: isDesktopUpdateButtonDisabled(updateState);
const actionLabel: Record<string, string> = { download: "Download", install: "Install" };
const statusLabel: Record<string, string> = {
checking: "Checking…",
downloading: "Downloading…",
// Off its track, "up to date" only means no switch is pending; Review moves it.
...(appOffTrack ? {} : { "up-to-date": "Up to Date" }),
};
const buttonLabel =
actionLabel[action] ?? statusLabel[updateState?.status ?? ""] ?? "Check for Updates";
const description =
action === "download" || action === "install"
? "Update available."
: (getDesktopUpdateDisabledReason(updateState, updatesDenial) ??
"Current version of the application.");
return (
<>
<SettingsRow
id={searchableSetting("app-version").id}
title={<AboutVersionTitle />}
description={description}
managed={updatesDenial}
control={
<Tooltip>
<TooltipTrigger
render={
<Button
size="sm"
variant="outline"
disabled={buttonDisabled || isUpdateActionPending}
onClick={handleButtonClick}
>
{buttonLabel}
</Button>
}
/>
{buttonTooltip ? <TooltipPopup>{buttonTooltip}</TooltipPopup> : null}
</Tooltip>
}
/>
{hasDesktopBridge ? (
<SettingsRow
{...searchableSetting("update-track")}
description={
nightlyDeniedBy !== undefined ? (
`${managedUpdatesMessage(nightlyDeniedBy)} Nightly builds are not available${
selectedUpdateChannel === "nightly"
? "; switch to Stable to keep getting updates."
: "."
}`
) : unswitchedMachines > 0 ? (
<>
{unswitchedMachines === 1
? "1 machine still runs"
: `${unswitchedMachines} machines still run`}{" "}
{channelSwitchLabel(selectedUpdateChannel === "nightly" ? "latest" : "nightly")}.{" "}
{/* The dialog moves what it can and says why it skips the rest. */}
<Button
size="xs"
variant="link"
disabled={updateRun !== null}
onClick={() => setSwitchChannel(selectedUpdateChannel)}
>
Review
</Button>
</>
) : (
"Switches this app and every connected machine whose database the target release supports."
)
}
managed={updatesDenial}
control={
<Select
value={selectedUpdateChannel}
onValueChange={(value) => {
if (value !== selectedUpdateChannel) {
setSwitchChannel(value as DesktopUpdateChannel);
}
}}
>
<SelectTrigger
size="sm"
className="w-full sm:w-40"
aria-label="Update track"
disabled={switchChannel !== null || updateRun !== null}
>
<SelectValue>{channelSwitchLabel(selectedUpdateChannel)}</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem hideIndicator value="latest">
Stable
</SelectItem>
<SelectItem
hideIndicator
value="nightly"
disabled={nightlyDeniedBy !== undefined && selectedUpdateChannel !== "nightly"}
>
Nightly
</SelectItem>
</SelectPopup>
</Select>
}
/>
) : selectedHostedAppChannel ? (
<SettingsRow
{...searchableSetting("update-track")}
description="Switches the hosted app release channel."
control={
<Select
value={selectedHostedAppChannel}
onValueChange={(value) => {
if (value === selectedHostedAppChannel) return;
window.location.assign(
buildHostedChannelSelectionUrl({ channel: value as HostedAppChannel }),
);
}}
>
<SelectTrigger size="sm" className="w-full sm:w-40" aria-label="Update track">
<SelectValue>{HOSTED_APP_CHANNEL_LABEL}</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem hideIndicator value="latest">
Latest
</SelectItem>
<SelectItem hideIndicator value="nightly">
Nightly
</SelectItem>
</SelectPopup>
</Select>
}
/>
) : null}
{hasDesktopBridge ? <CliCommandSettingsRow /> : null}
{switchChannel === null ? null : (
<UpdateTrackSwitchDialog channel={switchChannel} onClose={() => setSwitchChannel(null)} />
)}
</>
);
}
export function useSettingsRestore(onRestored?: () => void) {
const {
theme,
setTheme,
followSystem,
setFollowSystem,
setThemeHalf,
clearThemeHalves,
themeHalves,
} = useTheme();
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
const isTextGenerationModelDirty = !Equal.equals(
settings.textGenerationModelSelection ?? null,
DEFAULT_UNIFIED_SETTINGS.textGenerationModelSelection ?? null,
);
const isBackgroundActivityDirty = hasChangedBackgroundActivitySettings(settings);
const changedSettingLabels = [
...(theme !== "system" ? ["Theme"] : []),
...(!followSystem ? ["Follow system"] : []),
...(themeHalves !== null ? ["Theme mix"] : []),
...(settings.appearanceContrast !== DEFAULT_UNIFIED_SETTINGS.appearanceContrast
? ["Contrast"]
: []),
...(settings.glassOpacity !== DEFAULT_UNIFIED_SETTINGS.glassOpacity ? ["Glass opacity"] : []),
...(settings.diffColorScheme !== DEFAULT_UNIFIED_SETTINGS.diffColorScheme
? ["Diff colors"]
: []),
...(settings.chatWidth !== DEFAULT_UNIFIED_SETTINGS.chatWidth ? ["Chat width"] : []),
...(settings.effortDisplay !== DEFAULT_UNIFIED_SETTINGS.effortDisplay
? ["Effort display"]
: []),
...(settings.mathRenderingEnabled !== DEFAULT_UNIFIED_SETTINGS.mathRenderingEnabled
? ["Render math"]
: []),
...(settings.panelAnimationDurationMs !== DEFAULT_UNIFIED_SETTINGS.panelAnimationDurationMs
? ["Panel animations"]
: []),
...(settings.environmentIdentificationMode !==
DEFAULT_UNIFIED_SETTINGS.environmentIdentificationMode
? ["Environment identification"]
: []),
...(settings.timestampFormat !== DEFAULT_UNIFIED_SETTINGS.timestampFormat
? ["Time format"]
: []),
...(settings.notificationMode !== DEFAULT_UNIFIED_SETTINGS.notificationMode
? ["Thread notifications"]
: []),
...(settings.inAppNotificationsEnabled !== DEFAULT_UNIFIED_SETTINGS.inAppNotificationsEnabled
? ["In-app notifications"]
: []),
...(settings.sidebarProjectGroupingMode !== DEFAULT_UNIFIED_SETTINGS.sidebarProjectGroupingMode
? ["Project Grouping"]
: []),
...(settings.sidebarProjectSortOrder !== DEFAULT_UNIFIED_SETTINGS.sidebarProjectSortOrder
? ["Project order"]
: []),
...(settings.sidebarWorkingShelfEnabled !== DEFAULT_UNIFIED_SETTINGS.sidebarWorkingShelfEnabled
? ["Working section"]
: []),
...(settings.sidebarAutoSettleAfterDays !== DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleAfterDays
? ["Auto-settle inactive threads"]
: []),
...(settings.sidebarAutoSettleKeepPullRequests !==
DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleKeepPullRequests
? ["Keep threads with a PR"]
: []),
...(settings.sidebarAutoSettleOnMerge !== DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleOnMerge
? ["Auto-settle merged threads"]
: []),
...(settings.autoResumeLimitedThreads !== DEFAULT_UNIFIED_SETTINGS.autoResumeLimitedThreads
? ["Resume after usage limits"]
: []),
...(settings.snoozeLimitedThreads !== DEFAULT_UNIFIED_SETTINGS.snoozeLimitedThreads
? ["Snooze until limits reset"]
: []),
...(!Equal.equals(settings.snoozePresets, DEFAULT_UNIFIED_SETTINGS.snoozePresets)
? ["Snooze options"]
: []),
...(settings.wordWrap !== DEFAULT_UNIFIED_SETTINGS.wordWrap ? ["Word wrap"] : []),
...(settings.persistComposerContextStrip !==
DEFAULT_UNIFIED_SETTINGS.persistComposerContextStrip
? ["Composer context"]
: []),
...getChangedTypographySettingLabels(settings),
...(settings.diffFilesCollapsed !== DEFAULT_UNIFIED_SETTINGS.diffFilesCollapsed
? ["Default diff file state"]
: []),
...(settings.diffIgnoreWhitespace !== DEFAULT_UNIFIED_SETTINGS.diffIgnoreWhitespace
? ["Diff whitespace changes"]
: []),
...(settings.diffLayout !== DEFAULT_UNIFIED_SETTINGS.diffLayout ? ["Diff layout"] : []),
...(settings.proactivePanelsEnabled !== DEFAULT_UNIFIED_SETTINGS.proactivePanelsEnabled
? ["Open pull requests and changes panels proactively"]
: []),
...(settings.showSkillsInSlashMenu !== DEFAULT_UNIFIED_SETTINGS.showSkillsInSlashMenu
? ["Show skills in slash menu"]
: []),
...(settings.composerRichTextEnabled !== DEFAULT_UNIFIED_SETTINGS.composerRichTextEnabled
? ["Rich text composer"]
: []),
...(settings.sendShortcut !== DEFAULT_UNIFIED_SETTINGS.sendShortcut ? ["Send shortcut"] : []),
...(settings.followUpBehavior !== DEFAULT_UNIFIED_SETTINGS.followUpBehavior
? ["Follow-up behavior"]
: []),
...(settings.contextWindowMeterEnabled !== DEFAULT_UNIFIED_SETTINGS.contextWindowMeterEnabled
? ["Context window indicator"]
: []),
...(settings.responseStreamingMode !== DEFAULT_UNIFIED_SETTINGS.responseStreamingMode
? ["Response streaming"]
: []),
...(settings.enableProviderUpdateChecks !== DEFAULT_UNIFIED_SETTINGS.enableProviderUpdateChecks
? ["Provider update checks"]
: []),
...(settings.continueThreadsAfterServerUpdate !==
DEFAULT_UNIFIED_SETTINGS.continueThreadsAfterServerUpdate
? ["Continue threads after restarts"]
: []),
...(isBackgroundActivityDirty ? ["Background activity"] : []),
...(settings.defaultThreadEnvMode !== DEFAULT_UNIFIED_SETTINGS.defaultThreadEnvMode
? ["New thread mode"]
: []),
...(settings.newWorktreesStartFromOrigin !==
DEFAULT_UNIFIED_SETTINGS.newWorktreesStartFromOrigin
? ["New worktrees start from remote"]
: []),
...(settings.addProjectBaseDirectory !== DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory
? ["Add project base directory"]
: []),
...(settings.ghqCloneLayout !== DEFAULT_UNIFIED_SETTINGS.ghqCloneLayout
? ["Clone into host folders"]
: []),
...(settings.confirmThreadUnpin !== DEFAULT_UNIFIED_SETTINGS.confirmThreadUnpin
? ["Unpin confirmation"]
: []),
...(settings.confirmThreadArchive !== DEFAULT_UNIFIED_SETTINGS.confirmThreadArchive
? ["Archive confirmation"]
: []),
...(settings.confirmThreadDelete !== DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete
? ["Delete confirmation"]
: []),
...(settings.confirmQuit !== DEFAULT_UNIFIED_SETTINGS.confirmQuit ? ["Quit shortcut"] : []),
...(isTextGenerationModelDirty ? ["Text generation model"] : []),
...(settings.threadTitleInstructions !== DEFAULT_UNIFIED_SETTINGS.threadTitleInstructions
? ["Thread title instructions"]
: []),
...getChangedBrowserSettingLabels(settings),
...(settings.enableAgentBrowserAccess !== DEFAULT_UNIFIED_SETTINGS.enableAgentBrowserAccess
? ["Agent browser access"]
: []),
];
const restoreDefaults = async () => {
if (changedSettingLabels.length === 0) return;
const api = readLocalApi();
const confirmed = await (api ?? ensureLocalApi()).dialogs.confirm(
["Restore default settings?", `This will reset: ${changedSettingLabels.join(", ")}.`].join(
"\n",
),
{ variant: "destructive" },
);
if (!confirmed) return;
// Reset only dirty theme keys so storage failures cannot block other settings; re-read after confirmation
// for safe rollback.
let previousTheme = theme;
try {
previousTheme = readThemePreference();
} catch {}
const liveHalves = readThemeHalves();
const needsThemeReset = previousTheme !== "system";
const needsMixReset = liveHalves !== null;
const needsFollowSystemReset = readAppearanceModePreference(previousTheme) !== "system";
const notifyThemeRestoreFailure = () => {
toastManager.add(
stackedThreadToast({
type: "error",
title: "Couldn’t restore theme settings",
description: "Try again.",
}),
);
};
// Restore the base preference before the mix because restoring the base clears the mix.
const previousHalves = liveHalves;
const rollbackThemeState = () => {
if (needsThemeReset) setTheme(previousTheme);
if (previousHalves?.light) setThemeHalf("light", previousHalves.light);
if (previousHalves?.dark) setThemeHalf("dark", previousHalves.dark);
};
if (needsThemeReset && !setTheme("system")) {
notifyThemeRestoreFailure();
return;
}
if (needsMixReset && !clearThemeHalves()) {
rollbackThemeState();
notifyThemeRestoreFailure();
return;
}
if (needsFollowSystemReset && !setFollowSystem(true)) {
rollbackThemeState();
notifyThemeRestoreFailure();
return;
}
updateSettings({
appearanceContrast: DEFAULT_UNIFIED_SETTINGS.appearanceContrast,
diffColorScheme: DEFAULT_UNIFIED_SETTINGS.diffColorScheme,
chatWidth: DEFAULT_UNIFIED_SETTINGS.chatWidth,
effortDisplay: DEFAULT_UNIFIED_SETTINGS.effortDisplay,
mathRenderingEnabled: DEFAULT_UNIFIED_SETTINGS.mathRenderingEnabled,
timestampFormat: DEFAULT_UNIFIED_SETTINGS.timestampFormat,
notificationMode: DEFAULT_UNIFIED_SETTINGS.notificationMode,
inAppNotificationsEnabled: DEFAULT_UNIFIED_SETTINGS.inAppNotificationsEnabled,
wordWrap: DEFAULT_UNIFIED_SETTINGS.wordWrap,
persistComposerContextStrip: DEFAULT_UNIFIED_SETTINGS.persistComposerContextStrip,
diffFilesCollapsed: DEFAULT_UNIFIED_SETTINGS.diffFilesCollapsed,
diffIgnoreWhitespace: DEFAULT_UNIFIED_SETTINGS.diffIgnoreWhitespace,
diffLayout: DEFAULT_UNIFIED_SETTINGS.diffLayout,
proactivePanelsEnabled: DEFAULT_UNIFIED_SETTINGS.proactivePanelsEnabled,
showSkillsInSlashMenu: DEFAULT_UNIFIED_SETTINGS.showSkillsInSlashMenu,
composerRichTextEnabled: DEFAULT_UNIFIED_SETTINGS.composerRichTextEnabled,
sendShortcut: DEFAULT_UNIFIED_SETTINGS.sendShortcut,
followUpBehavior: DEFAULT_UNIFIED_SETTINGS.followUpBehavior,
contextWindowMeterEnabled: DEFAULT_UNIFIED_SETTINGS.contextWindowMeterEnabled,
environmentIdentificationMode: DEFAULT_UNIFIED_SETTINGS.environmentIdentificationMode,
glassOpacity: DEFAULT_UNIFIED_SETTINGS.glassOpacity,
panelAnimationDurationMs: DEFAULT_UNIFIED_SETTINGS.panelAnimationDurationMs,
sidebarProjectGroupingMode: DEFAULT_UNIFIED_SETTINGS.sidebarProjectGroupingMode,
sidebarProjectSortOrder: DEFAULT_UNIFIED_SETTINGS.sidebarProjectSortOrder,
sidebarWorkingShelfEnabled: DEFAULT_UNIFIED_SETTINGS.sidebarWorkingShelfEnabled,
sidebarAutoSettleAfterDays: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleAfterDays,
sidebarAutoSettleKeepPullRequests: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleKeepPullRequests,
sidebarAutoSettleOnMerge: DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleOnMerge,
autoResumeLimitedThreads: DEFAULT_UNIFIED_SETTINGS.autoResumeLimitedThreads,
snoozeLimitedThreads: DEFAULT_UNIFIED_SETTINGS.snoozeLimitedThreads,
snoozePresets: DEFAULT_UNIFIED_SETTINGS.snoozePresets,
responseStreamingMode: DEFAULT_UNIFIED_SETTINGS.responseStreamingMode,
enableProviderUpdateChecks: DEFAULT_UNIFIED_SETTINGS.enableProviderUpdateChecks,
continueThreadsAfterServerUpdate: DEFAULT_UNIFIED_SETTINGS.continueThreadsAfterServerUpdate,
backgroundActivity: DEFAULT_UNIFIED_SETTINGS.backgroundActivity,
backgroundActivityProfile: DEFAULT_UNIFIED_SETTINGS.backgroundActivityProfile,
automaticGitFetchInterval: DEFAULT_UNIFIED_SETTINGS.automaticGitFetchInterval,
providerHealthRefreshInterval: DEFAULT_UNIFIED_SETTINGS.providerHealthRefreshInterval,
defaultThreadEnvMode: DEFAULT_UNIFIED_SETTINGS.defaultThreadEnvMode,
newWorktreesStartFromOrigin: DEFAULT_UNIFIED_SETTINGS.newWorktreesStartFromOrigin,
addProjectBaseDirectory: DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory,
ghqCloneLayout: DEFAULT_UNIFIED_SETTINGS.ghqCloneLayout,
confirmThreadArchive: DEFAULT_UNIFIED_SETTINGS.confirmThreadArchive,
confirmThreadDelete: DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete,
confirmThreadUnpin: DEFAULT_UNIFIED_SETTINGS.confirmThreadUnpin,
confirmQuit: DEFAULT_UNIFIED_SETTINGS.confirmQuit,
textGenerationModelSelection: DEFAULT_UNIFIED_SETTINGS.textGenerationModelSelection,
threadTitleInstructions: DEFAULT_UNIFIED_SETTINGS.threadTitleInstructions,
fontFamilySans: DEFAULT_UNIFIED_SETTINGS.fontFamilySans,
fontFamilyComposer: DEFAULT_UNIFIED_SETTINGS.fontFamilyComposer,
fontFamilyCode: DEFAULT_UNIFIED_SETTINGS.fontFamilyCode,
fontFamilyTerminal: DEFAULT_UNIFIED_SETTINGS.fontFamilyTerminal,
fontSizeInterface: DEFAULT_UNIFIED_SETTINGS.fontSizeInterface,
fontSizePrompt: DEFAULT_UNIFIED_SETTINGS.fontSizePrompt,
fontSizeCode: DEFAULT_UNIFIED_SETTINGS.fontSizeCode,
fontSizeTerminal: DEFAULT_UNIFIED_SETTINGS.fontSizeTerminal,
browserDefaultViewport: DEFAULT_UNIFIED_SETTINGS.browserDefaultViewport,
browserDefaultZoomFactor: DEFAULT_UNIFIED_SETTINGS.browserDefaultZoomFactor,
browserDefaultAppearance: DEFAULT_UNIFIED_SETTINGS.browserDefaultAppearance,
browserRecordingFrameRate: DEFAULT_UNIFIED_SETTINGS.browserRecordingFrameRate,
browserRecordingShowKeyPresses: DEFAULT_UNIFIED_SETTINGS.browserRecordingShowKeyPresses,
browserRecordingShowMousePresses: DEFAULT_UNIFIED_SETTINGS.browserRecordingShowMousePresses,
browserLinkTarget: DEFAULT_UNIFIED_SETTINGS.browserLinkTarget,
browserSearchEngine: DEFAULT_UNIFIED_SETTINGS.browserSearchEngine,
browserCustomSearchUrl: DEFAULT_UNIFIED_SETTINGS.browserCustomSearchUrl,
browserAutoShowFloatingPreview: DEFAULT_UNIFIED_SETTINGS.browserAutoShowFloatingPreview,
pullRequestLinksOpenInApp: DEFAULT_UNIFIED_SETTINGS.pullRequestLinksOpenInApp,
enableAgentBrowserAccess: DEFAULT_UNIFIED_SETTINGS.enableAgentBrowserAccess,
});
onRestored?.();
};
return {
changedSettingLabels,
restoreDefaults,
};
}
const AUTO_SETTLE_DEFAULT_DAYS = DEFAULT_UNIFIED_SETTINGS.sidebarAutoSettleAfterDays ?? 3;
function AutoSettleDaysInput({
value,
onCommit,
}: {
value: number;
onCommit: (days: number) => void;
}) {
const [draft, setDraft] = useState(String(value));
const [draftSource, setDraftSource] = useState(value);
if (draftSource !== value) {
setDraftSource(value);
setDraft(String(value));
}
return (
<Input
size="sm"
type="number"
min={MIN_SIDEBAR_AUTO_SETTLE_AFTER_DAYS}
max={MAX_SIDEBAR_AUTO_SETTLE_AFTER_DAYS}
className="w-full sm:w-24"
value={draft}
onChange={(event) => {
setDraft(event.target.value);
const parsed = Number(event.target.value);
if (
Number.isInteger(parsed) &&
parsed >= MIN_SIDEBAR_AUTO_SETTLE_AFTER_DAYS &&
parsed <= MAX_SIDEBAR_AUTO_SETTLE_AFTER_DAYS
) {
onCommit(parsed);
}
}}
onBlur={() => setDraft(String(value))}
aria-label="Days of inactivity before auto-settle"
/>
);
}
export function LegacyFeaturesSection() {
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
return (
<SettingsSection id="legacy-features" title="Legacy">
<SettingsRow
{...searchableSetting("legacy-plan-mode")}
description="Restore Build/Plan, /plan, /default, and Shift+Tab. Off uses build mode."
control={
<Switch
checked={settings.planModeEnabled}
onCheckedChange={(checked) => {
updateSettings({ planModeEnabled: Boolean(checked) });
}}
aria-label="Plan mode (legacy)"
/>
}
/>
<SettingsRow
{...searchableSetting("legacy-context-window-indicator")}
description="Shows context window usage as a circular indicator in the composer."
control={
<Switch
checked={settings.contextWindowMeterEnabled}
onCheckedChange={(checked) =>
updateSettings({ contextWindowMeterEnabled: Boolean(checked) })
}
aria-label="Context window indicator (legacy)"
/>
}
/>
</SettingsSection>
);
}
export function GeneralSettingsPanel() {
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
const lastEnabledProjectGroupingMode = useRef<SidebarProjectGroupingMode>(
readLastEnabledProjectGroupingMode(),
);
return (
<SettingsPageContainer>
<SettingsSection id="notifications" title="Notifications">
<NotificationSettings />
<SettingsRow
{...searchableSetting("in-app-notifications")}
description="Show a toast when another thread finishes, fails, or needs input or approval while this app has focus."
control={
<Switch
checked={settings.inAppNotificationsEnabled}
onCheckedChange={(checked) => updateSettings({ inAppNotificationsEnabled: checked })}
aria-label="In-app notifications"
/>
}
/>
</SettingsSection>
<SettingsSection id="sidebar" title="Sidebar">
<SettingsRow
{...searchableSetting("project-grouping")}
description="Combine matching repositories across environments."
resetAction={
settings.sidebarProjectGroupingMode !==
DEFAULT_UNIFIED_SETTINGS.sidebarProjectGroupingMode ? (
<SettingResetButton
label="project grouping"
onClick={() =>
updateSettings({
sidebarProjectGroupingMode: DEFAULT_UNIFIED_SETTINGS.sidebarProjectGroupingMode,
})
}
/>
) : null
}
control={
<Switch
checked={isProjectGroupingEnabled(settings.sidebarProjectGroupingMode)}
onCheckedChange={(checked) => {
if (!checked && settings.sidebarProjectGroupingMode !== "separate") {
lastEnabledProjectGroupingMode.current = settings.sidebarProjectGroupingMode;
rememberEnabledProjectGroupingMode(settings.sidebarProjectGroupingMode);
}
updateSettings({
sidebarProjectGroupingMode: projectGroupingModeFromToggle(
checked,
lastEnabledProjectGroupingMode.current,
),
});
}}
aria-label="Project grouping"
/>
}
/>
<SettingsRow
{...searchableSetting("project-order")}
description="Order of projects in the sidebar project picker and command palette."
resetAction={
settings.sidebarProjectSortOrder !==
DEFAULT_UNIFIED_SETTINGS.sidebarProjectSortOrder ? (
<SettingResetButton
label="project order"
onClick={() =>
updateSettings({
sidebarProjectSortOrder: DEFAULT_UNIFIED_SETTINGS.sidebarProjectSortOrder,
})
}
/>
) : null
}
control={
<Select
value={settings.sidebarProjectSortOrder}
onValueChange={(value) => {
if (isSidebarProjectSortOrder(value)) {
updateSettings({ sidebarProjectSortOrder: value });
}
}}
>
<SelectTrigger size="sm" className="w-full sm:w-44" aria-label="Project order">
<SelectValue>
{SIDEBAR_PROJECT_SORT_ORDER_LABELS[settings.sidebarProjectSortOrder]}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
{SidebarProjectSortOrder.literals.map((sortOrder) => (
<SelectItem hideIndicator key={sortOrder} value={sortOrder}>
{SIDEBAR_PROJECT_SORT_ORDER_LABELS[sortOrder]}
</SelectItem>
))}
</SelectPopup>
</Select>
}
/>
<SettingsRow
{...searchableSetting("working-shelf")}
description="Fold working and monitoring threads into a Working section. They return to the top of the inbox when they need you. The boring sidebar in Labs has no Working section."
resetAction={
settings.sidebarWorkingShelfEnabled !==
DEFAULT_UNIFIED_SETTINGS.sidebarWorkingShelfEnabled ? (
<SettingResetButton
label="working section"
onClick={() =>
updateSettings({
sidebarWorkingShelfEnabled: DEFAULT_UNIFIED_SETTINGS.sidebarWorkingShelfEnabled,
})
}
/>
) : null
}
control={
<Switch
checked={settings.sidebarWorkingShelfEnabled}
onCheckedChange={(checked) =>
updateSettings({ sidebarWorkingShelfEnabled: Boolean(checked) })
}
aria-label="Working section"
/>
}
/>
</SettingsSection>
<SettingsSection id="confirmations" title="Confirmations">
<SettingsRow
{...searchableSetting("unpin-confirmation")}
description="Ask before unpinning a thread from the pinned section."
resetAction={
settings.confirmThreadUnpin !== DEFAULT_UNIFIED_SETTINGS.confirmThreadUnpin ? (
<SettingResetButton
label="unpin confirmation"
onClick={() =>
updateSettings({
confirmThreadUnpin: DEFAULT_UNIFIED_SETTINGS.confirmThreadUnpin,
})
}
/>
) : null
}
control={
<Switch
checked={settings.confirmThreadUnpin}
onCheckedChange={(checked) =>
updateSettings({ confirmThreadUnpin: Boolean(checked) })
}
aria-label="Confirm thread unpinning"
/>
}
/>
<SettingsRow
{...searchableSetting("archive-confirmation")}
description="Require a second click on the inline archive action before a thread is archived."
resetAction={
settings.confirmThreadArchive !== DEFAULT_UNIFIED_SETTINGS.confirmThreadArchive ? (
<SettingResetButton
label="archive confirmation"
onClick={() =>
updateSettings({
confirmThreadArchive: DEFAULT_UNIFIED_SETTINGS.confirmThreadArchive,
})
}
/>
) : null
}
control={
<Switch
checked={settings.confirmThreadArchive}
onCheckedChange={(checked) =>
updateSettings({ confirmThreadArchive: Boolean(checked) })
}
aria-label="Confirm thread archiving"
/>
}
/>
<SettingsRow
{...searchableSetting("delete-confirmation")}
description="Ask before deleting a thread and its chat history."
resetAction={
settings.confirmThreadDelete !== DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete ? (
<SettingResetButton
label="delete confirmation"
onClick={() =>
updateSettings({
confirmThreadDelete: DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete,
})
}
/>
) : null
}
control={
<Switch
checked={settings.confirmThreadDelete}
onCheckedChange={(checked) =>
updateSettings({ confirmThreadDelete: Boolean(checked) })
}
aria-label="Confirm thread deletion"
/>
}
/>
{isElectron ? (
<SettingsRow
{...searchableSetting("quit-confirmation")}
description="Hold mode also quits on two quick presses."
resetAction={
settings.confirmQuit !== DEFAULT_UNIFIED_SETTINGS.confirmQuit ? (
<SettingResetButton
label="quit shortcut behavior"
onClick={() =>
updateSettings({ confirmQuit: DEFAULT_UNIFIED_SETTINGS.confirmQuit })
}
/>
) : null
}
control={
<Select
value={settings.confirmQuit}
onValueChange={(value) => {
if (value === "direct" || value === "hold" || value === "double-click") {
updateSettings({ confirmQuit: value });
}
}}
>
<SelectTrigger
size="sm"
className="w-full sm:w-40"
aria-label="Quit shortcut behavior"
>
<SelectValue>{QUIT_CONFIRMATION_MODE_LABELS[settings.confirmQuit]}</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
{Object.entries(QUIT_CONFIRMATION_MODE_LABELS).map(([value, label]) => (
<SelectItem hideIndicator key={value} value={value}>
{label}
</SelectItem>
))}
</SelectPopup>
</Select>
}
/>
) : null}
</SettingsSection>
<SettingsSection id="display" title="Display">
<SettingsRow
{...searchableSetting("time-format")}
description="System default follows your browser or OS clock preference."
resetAction={
settings.timestampFormat !== DEFAULT_UNIFIED_SETTINGS.timestampFormat ? (
<SettingResetButton
label="time format"
onClick={() =>
updateSettings({
timestampFormat: DEFAULT_UNIFIED_SETTINGS.timestampFormat,
})
}
/>
) : null
}
control={
<Select
value={settings.timestampFormat}
onValueChange={(value) => {
if (value === "locale" || value === "12-hour" || value === "24-hour") {
updateSettings({ timestampFormat: value });
}
}}
>
<SelectTrigger size="sm" className="w-full sm:w-40" aria-label="Timestamp format">
<SelectValue>{TIMESTAMP_FORMAT_LABELS[settings.timestampFormat]}</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem hideIndicator value="locale">
{TIMESTAMP_FORMAT_LABELS.locale}
</SelectItem>
<SelectItem hideIndicator value="12-hour">
{TIMESTAMP_FORMAT_LABELS["12-hour"]}
</SelectItem>
<SelectItem hideIndicator value="24-hour">
{TIMESTAMP_FORMAT_LABELS["24-hour"]}
</SelectItem>
</SelectPopup>
</Select>
}
/>
</SettingsSection>
</SettingsPageContainer>
);
}
export function ChatSettingsPanel() {
const modifierLabel = isMacPlatform(navigator.platform) ? "⌘" : "Ctrl";
const sendShortcutOptions = [
{ value: "enter", label: "Enter" },
{ value: "mod-enter-multiline", label: `${modifierLabel} + Enter for multiline prompts` },
{ value: "mod-enter", label: `${modifierLabel} + Enter always` },
] as const;
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
return (
<SettingsPageContainer>
<SettingsSection id="composer" title="Composer">
<SettingsRow
{...searchableSetting("composer-rich-text")}
description="Show formatted Markdown as you type."
resetAction={
settings.composerRichTextEnabled !==
DEFAULT_UNIFIED_SETTINGS.composerRichTextEnabled ? (
<SettingResetButton
label="rich text composer"
onClick={() =>
updateSettings({
composerRichTextEnabled: DEFAULT_UNIFIED_SETTINGS.composerRichTextEnabled,
})
}
/>
) : null
}
control={
<Switch
checked={settings.composerRichTextEnabled}
onCheckedChange={(checked) =>
updateSettings({ composerRichTextEnabled: Boolean(checked) })
}
aria-label="Rich text composer"
/>
}
/>
<SettingsRow
{...searchableSetting("send-shortcut")}
description="Choose when Enter sends a prompt or inserts a new line"
resetAction={
settings.sendShortcut !== DEFAULT_UNIFIED_SETTINGS.sendShortcut ? (
<SettingResetButton
label="send shortcut"
onClick={() =>
updateSettings({ sendShortcut: DEFAULT_UNIFIED_SETTINGS.sendShortcut })
}
/>
) : null
}
control={
<Select
value={settings.sendShortcut}
onValueChange={(value) => {
const option = sendShortcutOptions.find((option) => option.value === value);
if (option) updateSettings({ sendShortcut: option.value });
}}
>
<SelectTrigger
size="sm"
className="w-auto min-w-0 max-w-full"
aria-label="Send shortcut"
>
<SelectValue>
{
sendShortcutOptions.find((option) => option.value === settings.sendShortcut)
?.label
}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
{sendShortcutOptions.map((option) => (
<SelectItem key={option.value} value={option.value}>
<span className="flex items-center justify-between gap-4">
{option.label}
{settings.sendShortcut === option.value && <CheckIcon aria-hidden="true" />}
</span>
</SelectItem>
))}
</SelectPopup>
</Select>
}
/>
<AdvancedSettings targetIds={[searchableSetting("skills-in-slash-menu").id]}>
<SettingsRow
{...searchableSetting("skills-in-slash-menu")}
description="Also include skills in the / command menu. Skills always appear when you type $."
resetAction={
settings.showSkillsInSlashMenu !== DEFAULT_UNIFIED_SETTINGS.showSkillsInSlashMenu ? (
<SettingResetButton
label="skills in slash menu"
onClick={() =>
updateSettings({
showSkillsInSlashMenu: DEFAULT_UNIFIED_SETTINGS.showSkillsInSlashMenu,
})
}
/>
) : null
}
control={
<Switch
checked={settings.showSkillsInSlashMenu}
onCheckedChange={(checked) =>
updateSettings({ showSkillsInSlashMenu: Boolean(checked) })
}
aria-label="Show skills in slash menu"
/>
}
/>
</AdvancedSettings>
</SettingsSection>
<SettingsSection id="follow-ups" title="Follow-ups">
<SettingsRow
{...searchableSetting("follow-up-behavior")}
description={
"Queue follow-ups while the agent runs or steer the current run. " +
(settings.sendShortcut === "mod-enter-multiline"
? `Press ${modifierLabel} + Enter for single-line prompts or ${modifierLabel} + Shift + Enter for multiline prompts to do the opposite for one message.`
: `Press ${modifierLabel}${settings.sendShortcut === "mod-enter" ? " + Shift" : ""} + Enter to do the opposite for one message.`)
}
resetAction={
settings.followUpBehavior !== DEFAULT_UNIFIED_SETTINGS.followUpBehavior ? (
<SettingResetButton
label="follow-up behavior"
onClick={() =>
updateSettings({
followUpBehavior: DEFAULT_UNIFIED_SETTINGS.followUpBehavior,
})
}
/>
) : null
}
control={
<Select
value={settings.followUpBehavior}
onValueChange={(value) => {
if (value === "queue" || value === "steer") {
updateSettings({ followUpBehavior: value });
}
}}
>
<SelectTrigger size="sm" className="w-auto min-w-0" aria-label="Follow-up behavior">
<SelectValue>
{settings.followUpBehavior === "queue" ? "Queue" : "Steer"}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem value="queue">Queue</SelectItem>
<SelectItem value="steer">Steer</SelectItem>
</SelectPopup>
</Select>
}
/>
</SettingsSection>
</SettingsPageContainer>
);
}
function DiffColorsSettingsRow() {
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
return (
<SettingsRow
{...searchableSetting("diff-color-scheme")}
description="Choose colors for additions and deletions, including change counts."
resetAction={
settings.diffColorScheme !== DEFAULT_UNIFIED_SETTINGS.diffColorScheme ? (
<SettingResetButton
label="diff colors"
onClick={() =>
updateSettings({ diffColorScheme: DEFAULT_UNIFIED_SETTINGS.diffColorScheme })
}
/>
) : null
}
control={
<div className="w-full sm:w-40">
<Select
value={settings.diffColorScheme}
onValueChange={(value) => {
if (value === "red-green" || value === "blue-orange")
updateSettings({ diffColorScheme: value });
}}
>
<SelectTrigger size="sm" className="w-full min-w-0" aria-label="Diff colors">
<span
aria-hidden="true"
className={
settings.diffColorScheme === "blue-orange"
? "flex shrink-0 flex-row-reverse gap-1"
: "flex shrink-0 gap-1"
}
>
<span className="size-2 rounded-full bg-diff-deletion" />
<span className="size-2 rounded-full bg-diff-addition" />
</span>
<SelectValue>
{settings.diffColorScheme === "blue-orange" ? "Blue & orange" : "Red & green"}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem value="red-green">Red & green (default)</SelectItem>
<SelectItem value="blue-orange">Blue & orange</SelectItem>
</SelectPopup>
</Select>
</div>
}
/>
);
}
export function DiffsSettingsPanel() {
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
return (
<SettingsPageContainer>
<SettingsSection id="diffs" title="Diffs">
<SettingsRow
{...searchableSetting("diff-layout")}
description="Show diffs stacked or side by side. The toggle in the diff toolbar changes this too."
resetAction={
settings.diffLayout !== DEFAULT_UNIFIED_SETTINGS.diffLayout ? (
<SettingResetButton
label="diff layout"
onClick={() => updateSettings({ diffLayout: DEFAULT_UNIFIED_SETTINGS.diffLayout })}
/>
) : null
}
control={
<Select
value={settings.diffLayout}
onValueChange={(value) => {
if (value === "stacked" || value === "split") {
updateSettings({ diffLayout: value });
}
}}
>
<SelectTrigger size="sm" className="w-full sm:w-40" aria-label="Diff layout">
<SelectValue>{DIFF_LAYOUT_LABELS[settings.diffLayout]}</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem hideIndicator value="stacked">
{DIFF_LAYOUT_LABELS.stacked}
</SelectItem>
<SelectItem hideIndicator value="split">
{DIFF_LAYOUT_LABELS.split}
</SelectItem>
</SelectPopup>
</Select>
}
/>
<SettingsRow
{...searchableSetting("hide-whitespace-changes")}
description="Set whether the diff panel ignores whitespace-only edits by default."
resetAction={
settings.diffIgnoreWhitespace !== DEFAULT_UNIFIED_SETTINGS.diffIgnoreWhitespace ? (
<SettingResetButton
label="diff whitespace changes"
onClick={() =>
updateSettings({
diffIgnoreWhitespace: DEFAULT_UNIFIED_SETTINGS.diffIgnoreWhitespace,
})
}
/>
) : null
}
control={
<Switch
checked={settings.diffIgnoreWhitespace}
onCheckedChange={(checked) =>
updateSettings({ diffIgnoreWhitespace: Boolean(checked) })
}
aria-label="Hide whitespace changes by default"
/>
}
/>
<SettingsRow
{...searchableSetting("default-diff-file-state")}
description="Start with files expanded or collapsed when opening diffs or a pull request's Code tab."
resetAction={
settings.diffFilesCollapsed !== DEFAULT_UNIFIED_SETTINGS.diffFilesCollapsed ? (
<SettingResetButton
label="default diff file state"
onClick={() =>
updateSettings({
diffFilesCollapsed: DEFAULT_UNIFIED_SETTINGS.diffFilesCollapsed,
})
}
/>
) : null
}
control={
<Select
value={settings.diffFilesCollapsed ? "collapsed" : "expanded"}
onValueChange={(value) => {
if (value === "expanded" || value === "collapsed") {
updateSettings({ diffFilesCollapsed: value === "collapsed" });
}
}}
>
<SelectTrigger
size="sm"
className="w-full sm:w-40"
aria-label="Default diff file state"
>
<SelectValue>{settings.diffFilesCollapsed ? "Collapsed" : "Expanded"}</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem hideIndicator value="expanded">
Expanded
</SelectItem>
<SelectItem hideIndicator value="collapsed">
Collapsed
</SelectItem>
</SelectPopup>
</Select>
}
/>
<DiffColorsSettingsRow />
</SettingsSection>
<SettingsSection id="pull-requests" title="Pull requests">
<SettingsRow
{...searchableSetting("proactive-panels")}
description="Open linked pull requests first. Otherwise, open Changes for edits to at least 3 files or 50 lines."
resetAction={
settings.proactivePanelsEnabled !== DEFAULT_UNIFIED_SETTINGS.proactivePanelsEnabled ? (
<SettingResetButton
label="proactive panels"
onClick={() =>
updateSettings({
proactivePanelsEnabled: DEFAULT_UNIFIED_SETTINGS.proactivePanelsEnabled,
})
}
/>
) : null
}
control={
<Switch
checked={settings.proactivePanelsEnabled}
onCheckedChange={(checked) =>
updateSettings({ proactivePanelsEnabled: Boolean(checked) })
}
aria-label="Open pull requests and changes panels proactively"
/>
}
/>
<PullRequestLinksOpenInAppSetting />
</SettingsSection>
</SettingsPageContainer>
);
}
/** The Providers panel can render without a settings scope, as its tests do; this row needs one. */
export function CompactIdleThreadsRow() {
return useOptionalSettingsScope() === null ? null : <ScopedCompactIdleThreadsRow />;
}
function ScopedCompactIdleThreadsRow() {
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
const { targets } = useSettingsScope();
const idleCompaction = scopedIdleCompaction(targets.length > 0 ? targets : [{ settings }]);
return (
<SettingsRow
serverScoped
settingKeys={["idleCompaction", "compactIdleThreads"]}
mixed={idleCompaction.mixed}
{...searchableSetting("compact-idle-threads")}
description="When to compact an idle Claude thread over 200,000 tokens: after you return, just before its prompt cache expires, or never. Each Claude provider can override this."
resetAction={
globalIdleCompaction(settings) !== globalIdleCompaction(DEFAULT_UNIFIED_SETTINGS) ? (
<SettingResetButton
label="compact idle threads"
onClick={() =>
updateSettings({ idleCompaction: globalIdleCompaction(DEFAULT_UNIFIED_SETTINGS) })
}
/>
) : null
}
control={
<Select
value={idleCompaction.mixed ? null : globalIdleCompaction(settings)}
onValueChange={(value) => {
const mode = IDLE_COMPACTION_MODES.find((candidate) => candidate.value === value);
if (mode) updateSettings({ idleCompaction: mode.value });
}}
>
<SelectTrigger size="sm" className="w-full sm:w-56" aria-label="Compact idle threads">
<SelectValue>
{(value: string | null) =>
value === null
? "Mixed"
: IDLE_COMPACTION_MODES.find((mode) => mode.value === value)?.label
}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
{IDLE_COMPACTION_MODES.map((mode) => (
<SelectItem
hideIndicator
key={mode.value}
value={mode.value}
// A server from before modes has only the on/off switch, so it cannot store "Never".
disabled={mode.value === "off" && !idleCompaction.neverAvailable}
>
{mode.label}
</SelectItem>
))}
</SelectPopup>
</Select>
}
/>
);
}
export function ThreadsSettingsPanel() {
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
const navigate = useNavigate();
const { environment, connectedEnvironments, target, scope } = useSettingsScope();
const isProjectScope = scope.kind === "project" || scope.kind === "checkout";
const environmentId = environment?.environmentId ?? null;
const hasServerTargets = connectedEnvironments.length > 0;
const mixedResponseStreamingMode = useScopedSettingsMixed(["responseStreamingMode"]);
const providersByEnvironment = useEnvironmentProviders();
const serverProviders =
(environment?.serverConfig
? providersByEnvironment.get(environment.environmentId)
: undefined) ?? EMPTY_SERVER_PROVIDERS;
const supportsAutoSettlementScope = connectedEnvironments.every(
(target) => target.serverConfig?.environment.capabilities.threadAutoSettlementScope === true,
);
const textGenerationProviders = serverProviders.filter(
(provider) => provider.supportsTextGeneration !== false,
);
const textGenerationModelSelection = resolveAppModelSelectionState(
settings,
textGenerationProviders,
);
const textGenInstanceId = textGenerationModelSelection.instanceId;
const textGenModel = textGenerationModelSelection.model;
const textGenModelOptions = textGenerationModelSelection.options;
const textGenerationModelInstanceEntries = providerInstanceEntriesFor(
textGenerationProviders,
settings,
target?.projectId ?? null,
);
const hasTextGenerationProvider = textGenerationModelInstanceEntries.some(
(entry) => entry.enabled && entry.isAvailable,
);
const textGenInstanceEntry = textGenerationModelInstanceEntries.find(
(entry) => entry.instanceId === textGenInstanceId,
);
const textGenProvider: ProviderDriverKind =
textGenInstanceEntry?.driverKind ?? DEFAULT_DRIVER_KIND;
const textGenerationModelOptionsByInstance = getCustomModelOptionsByInstance(
settings,
textGenerationProviders,
textGenInstanceId,
textGenModel,
);
const isTextGenerationModelDirty = !Equal.equals(
settings.textGenerationModelSelection ?? null,
DEFAULT_UNIFIED_SETTINGS.textGenerationModelSelection ?? null,
);
const textGenerationModelDisabledReason = useScopedModelDisabledReason(
settings,
textGenerationModelInstanceEntries,
);
const mixedAddProjectBaseDirectory = useScopedSettingsMixed(["addProjectBaseDirectory"]);
const mixedTextGenerationModel = useScopedSettingsMixed(["textGenerationModelSelection"]);
return (
<SettingsPageContainer>
<SettingsSection id="new-projects" title="New projects">
<SettingsRow
serverScoped
settingKeys={["addProjectBaseDirectory"]}
{...searchableSetting("add-project-starts-in")}
description='Leave empty to use "~/" when the Add Project browser opens.'
resetAction={
settings.addProjectBaseDirectory !==
DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory ? (
<SettingResetButton
label="add project base directory"
onClick={() =>
updateSettings({
addProjectBaseDirectory: DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory,
})
}
/>
) : null
}
control={
<DraftInput
size="sm"
className="w-full sm:w-72"
value={mixedAddProjectBaseDirectory ? "" : settings.addProjectBaseDirectory}
onCommit={(next) => updateSettings({ addProjectBaseDirectory: next })}
normalizeDraft={resolvePastedPath}
placeholder={mixedAddProjectBaseDirectory ? "Mixed" : "~/"}
spellCheck={false}
aria-label="Add project base directory"
/>
}
/>
<SettingsRow
serverScoped
settingKeys={["ghqCloneLayout"]}
{...searchableSetting("ghq-clone-layout")}
description="Clones go to github.com/owner/repo under the folder above, like ghq."
resetAction={
settings.ghqCloneLayout !== DEFAULT_UNIFIED_SETTINGS.ghqCloneLayout ? (
<SettingResetButton
label="clone into host folders"
onClick={() =>
updateSettings({ ghqCloneLayout: DEFAULT_UNIFIED_SETTINGS.ghqCloneLayout })
}
/>
) : null
}
control={
<ScopedSwitch
settingKeys={["ghqCloneLayout"]}
checked={settings.ghqCloneLayout}
onCheckedChange={(checked) => updateSettings({ ghqCloneLayout: Boolean(checked) })}
aria-label="Clone into host folders"
/>
}
/>
</SettingsSection>
<ProjectDefaultsSettings category="general" />
{!isProjectScope ? (
<SettingsSection id="snooze" title="Snooze">
<SnoozePresetsRow />
</SettingsSection>
) : null}
<SettingsSection id="usage-limits" title="Usage limits">
<SettingsRow
serverScoped
{...searchableSetting("auto-resume-limited-threads")}
description="Automatically resume threads when their usage limits reset. You can cancel auto-resume in each thread."
settingKeys={["autoResumeLimitedThreads"]}
control={
<ScopedSwitch