Files
clash-verge-rev/src/components/home/proxy-tun-card.tsx
T
wonfen 22947632c0 refactor: Rewrite and improve sysproxy logic (#7744)
* fix(cmd): preserve anyhow context in coded errors

Use alternate error formatting so coded failures retain the full anyhow context chain without changing their wire format.

* fix(macos): skip redundant proxy disable writes

When both proxy modes are off, read macOS state first and skip networksetup if the OS is already clean. Update the guard target only after a successful write.

* feat(proxy): classify system proxy failures

Attach stable, actionable proxy failure codes to anyhow chains while preserving the original diagnostic causes.

* feat(cmd): return structured command failures

Replace encoded error strings with serializable code and detail fields, and update frontend notice consumers to handle the structured shape.

* fix(scripts): use the js-yaml namespace import

Import js-yaml through its ESM namespace so the i18n cleanup script can access load and dump.

* feat(proxy): localize classified proxy failures

Map privilege and direct-fallback codes to localized explanations, and let mapped causes outrank generic operation keys in notices.

* fix(ui): bound notice text and render failure details

Limit resolved notice text without truncating clipboard content, and normalize structured failures embedded in translation parameters.

* feat(proxy): persist unseen proxy failures

Store unresolved classified failures by code, notify the frontend when the table changes, and show each failure sequence once when a visible window can receive it.

* feat(proxy): report tray and hotkey toggle failures

Record classified failures from tray and hotkey proxy toggles so they appear when a visible window is available.

* fix(ui): restore the proxy switch after failed toggles

Refresh frontend proxy state after a failed toggle so the switch reflects the rolled-back configuration.

* feat(proxy): stop the guard after repeated failures

Report guard outcomes, stop after the failure threshold, and persist the classified failure for the frontend.

* fix(macos): preserve proxy during service handoff

Stop a sidecar being handed to the service without clearing proxy state that the new owner must inherit.

* feat(macos): classify misplaced sidecar state

Distinguish a refused sidecar proxy write from a machine that still needs the privileged service installed.

* feat(ui): recover misplaced sidecar notices

Offer a restart action for macOS proxy failures caused by a ready service while the core still runs as a sidecar.

* feat(ui): install the service from proxy notices

Let privilege notices install the macOS service, restart the core, and report the runtime mode that was actually reached.

* feat(cmd): attach requested proxy operations

Carry the requested proxy direction with structured command failures when the originating command knows it.

* feat(sysproxy): drain guards before OS access

Wait for the local proxy guard to stop before OS reads, service handoff, or final writes, and refuse transitions when it does not drain.

* feat(sysproxy): recover partial proxy writes

Use write progress to choose whether to restore the old guard or compensate with a disabled proxy state, while preserving actionable errors.

* feat(sysproxy): skip already-applied proxy writes

Compare macOS proxy snapshots with global, PAC, and disabled targets so matching state avoids redundant privileged writes.

* feat(proxy): report background proxy failures

Persist and surface classified proxy failures from lifecycle paths that have no direct caller awaiting the result.

* feat(ui): move proxy recovery into a dialog

Guide users through installing or switching to the service after a refused proxy write, and suppress duplicate toast reports.

* fix(ui): close proxy dialog after service recovery

Dismiss the recovery dialog once the core reaches service mode, even when the original proxy request remains pending.

* feat(ui): retry proxy request after service recovery

Replay the requested proxy direction after the core reaches service mode, while leaving incidental restores unchanged.

* fix(proxy): refresh state after successful apply

Publish the proxy refresh from the shared apply path after releasing the lifecycle lock, and remove the tray-specific duplicate.

* feat(ui): show proxy recovery progress

Display installation, restart, and proxy-apply stages while keeping the primary action spinner visible during recovery.

* feat(ui): route unavailable TUN through service recovery

Let the TUN switch request service recovery and restore its requested state after the core restarts in service mode.

* fix(ui): avoid duplicate TUN recovery errors

Roll back deferred TUN toggles without reporting an error, and publish configuration refreshes from the transaction commit path.

* chore: update changelog & pinlock

* fix(core): resolve platform-specific clippy warnings

* fix(core): detect Windows wildcard TCP conflicts

Windows permits a specific exclusive bind beside an existing non-exclusive wildcard listener. Consult the system TCP listener table so the probe reports that overlap as a conflict.
2026-08-14 23:52:37 +08:00

245 lines
6.4 KiB
TypeScript

import {
ComputerRounded,
TroubleshootRounded,
HelpOutlineRounded,
SvgIconComponent,
} from '@mui/icons-material'
import {
Box,
Typography,
Stack,
Paper,
Tooltip,
alpha,
useTheme,
Fade,
} from '@mui/material'
import { useState, useMemo, memo, FC } from 'react'
import { useTranslation } from 'react-i18next'
import ProxyControlSwitches from '@/components/shared/proxy-control-switches'
import { useSystemProxyState } from '@/hooks/use-system-proxy-state'
import { useSystemState } from '@/hooks/use-system-state'
import { useVerge } from '@/hooks/use-verge'
import { showNotice } from '@/services/notice-service'
const LOCAL_STORAGE_TAB_KEY = 'clash-verge-proxy-active-tab'
interface TabButtonProps {
isActive: boolean
onClick: () => void
icon: SvgIconComponent
label: string
hasIndicator?: boolean
}
// Tab组件
const TabButton: FC<TabButtonProps> = memo(
({ isActive, onClick, icon: Icon, label, hasIndicator = false }) => (
<Paper
elevation={isActive ? 2 : 0}
onClick={onClick}
sx={{
cursor: 'pointer',
px: 2,
py: 1,
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
gap: 1,
bgcolor: isActive ? 'primary.main' : 'background.paper',
color: isActive ? 'primary.contrastText' : 'text.primary',
borderRadius: 1.5,
flex: 1,
maxWidth: 160,
transition: 'all 0.2s ease-in-out',
position: 'relative',
'&:hover': {
transform: 'translateY(-1px)',
boxShadow: 1,
},
'&:after': isActive
? {
content: '""',
position: 'absolute',
bottom: -9,
left: '50%',
width: 2,
height: 9,
bgcolor: 'primary.main',
transform: 'translateX(-50%)',
}
: {},
}}
>
<Icon fontSize="small" />
<Typography variant="body2" sx={{ fontWeight: isActive ? 600 : 400 }}>
{label}
</Typography>
{hasIndicator && (
<Box
sx={{
width: 8,
height: 8,
borderRadius: '50%',
bgcolor: isActive ? '#fff' : 'success.main',
position: 'absolute',
top: 8,
right: 8,
}}
/>
)}
</Paper>
),
)
interface TabDescriptionProps {
description: string
tooltipTitle: string
}
// 描述文本组件
const TabDescription: FC<TabDescriptionProps> = memo(
({ description, tooltipTitle }) => (
<Fade in={true} timeout={200}>
<Typography
variant="caption"
component="div"
sx={{
width: '95%',
textAlign: 'center',
color: 'text.secondary',
p: 0.8,
borderRadius: 1,
borderColor: 'primary.main',
borderWidth: 1,
borderStyle: 'solid',
backgroundColor: 'background.paper',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
gap: 0.5,
wordBreak: 'break-word',
hyphens: 'auto',
}}
>
{description}
<Tooltip title={tooltipTitle}>
<HelpOutlineRounded
sx={{ fontSize: 14, opacity: 0.7, flexShrink: 0 }}
/>
</Tooltip>
</Typography>
</Fade>
),
)
export const ProxyTunCard: FC = () => {
const { t } = useTranslation()
const theme = useTheme()
const [activeTab, setActiveTab] = useState<string>(
() => localStorage.getItem(LOCAL_STORAGE_TAB_KEY) || 'system',
)
const { verge } = useVerge()
const { isTunModeAvailable } = useSystemState()
// Display the observed OS state, not the requested configuration.
const { indicator: systemProxyIndicator } = useSystemProxyState()
const { enable_tun_mode } = verge ?? {}
const handleError = (err: unknown) => {
showNotice.error(err)
}
const handleTabChange = (tab: string) => {
setActiveTab(tab)
localStorage.setItem(LOCAL_STORAGE_TAB_KEY, tab)
}
const tabDescription = useMemo(() => {
if (activeTab === 'system') {
return {
text: systemProxyIndicator
? t('home.components.proxyTun.status.systemProxyEnabled')
: t('home.components.proxyTun.status.systemProxyDisabled'),
tooltip: t('home.components.proxyTun.tooltips.systemProxy'),
}
} else {
return {
text: !isTunModeAvailable
? t('home.components.proxyTun.status.tunModeServiceRequired')
: enable_tun_mode
? t('home.components.proxyTun.status.tunModeEnabled')
: t('home.components.proxyTun.status.tunModeDisabled'),
tooltip: t('home.components.proxyTun.tooltips.tunMode'),
}
}
}, [activeTab, systemProxyIndicator, enable_tun_mode, isTunModeAvailable, t])
return (
<Box sx={{ display: 'flex', flexDirection: 'column', width: '100%' }}>
<Stack
direction="row"
spacing={1}
sx={{
display: 'flex',
justifyContent: 'center',
position: 'relative',
zIndex: 2,
}}
>
<TabButton
isActive={activeTab === 'system'}
onClick={() => handleTabChange('system')}
icon={ComputerRounded}
label={t('settings.sections.system.toggles.systemProxy')}
hasIndicator={systemProxyIndicator}
/>
<TabButton
isActive={activeTab === 'tun'}
onClick={() => handleTabChange('tun')}
icon={TroubleshootRounded}
label={t('settings.sections.system.toggles.tunMode')}
hasIndicator={enable_tun_mode && isTunModeAvailable}
/>
</Stack>
<Box
sx={{
width: '100%',
my: 1,
position: 'relative',
display: 'flex',
justifyContent: 'center',
overflow: 'visible',
}}
>
<TabDescription
description={tabDescription.text}
tooltipTitle={tabDescription.tooltip}
/>
</Box>
<Box
sx={{
mt: 0,
p: 1,
bgcolor: alpha(theme.palette.primary.main, 0.04),
borderRadius: 2,
}}
>
<ProxyControlSwitches
onError={handleError}
label={
activeTab === 'system'
? t('settings.sections.system.toggles.systemProxy')
: t('settings.sections.system.toggles.tunMode')
}
noRightPadding={true}
/>
</Box>
</Box>
)
}