mirror of
https://github.com/clash-verge-rev/clash-verge-rev.git
synced 2026-11-18 09:52:13 +08:00
* 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.
245 lines
6.4 KiB
TypeScript
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>
|
|
)
|
|
}
|