1667 lines
63 KiB
JavaScript
1667 lines
63 KiB
JavaScript
// sidepanel/ip-proxy-panel.js — IP代理面板（轻量解耦）
|
||
function normalizeIpProxyService(value = '') {
|
||
const normalized = String(value || '').trim().toLowerCase();
|
||
const enabledServices = Array.isArray(globalThis.IP_PROXY_ENABLED_SERVICES)
|
||
? globalThis.IP_PROXY_ENABLED_SERVICES
|
||
: [DEFAULT_IP_PROXY_SERVICE];
|
||
if (enabledServices.includes(normalized)) {
|
||
return normalized;
|
||
}
|
||
return DEFAULT_IP_PROXY_SERVICE;
|
||
}
|
||
|
||
const ipProxyActionState = {
|
||
busy: false,
|
||
action: '',
|
||
startedAt: 0,
|
||
};
|
||
const IP_PROXY_ACTION_LOCK_TIMEOUT_MS = 25000;
|
||
let ipProxyDeferredProbeTimer = 0;
|
||
const IP_PROXY_SECTION_EXPANDED_STORAGE_KEY = 'multipage-ip-proxy-section-expanded';
|
||
let ipProxySectionExpanded = false;
|
||
|
||
function readIpProxySectionExpanded() {
|
||
try {
|
||
return globalThis.localStorage?.getItem(IP_PROXY_SECTION_EXPANDED_STORAGE_KEY) === '1';
|
||
} catch (err) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function persistIpProxySectionExpanded(expanded) {
|
||
try {
|
||
if (expanded) {
|
||
globalThis.localStorage?.setItem(IP_PROXY_SECTION_EXPANDED_STORAGE_KEY, '1');
|
||
} else {
|
||
globalThis.localStorage?.removeItem(IP_PROXY_SECTION_EXPANDED_STORAGE_KEY);
|
||
}
|
||
} catch (err) {
|
||
// Ignore storage errors; the in-memory collapsed state is still enough for this session.
|
||
}
|
||
}
|
||
|
||
function setIpProxySectionExpanded(expanded) {
|
||
ipProxySectionExpanded = Boolean(expanded);
|
||
persistIpProxySectionExpanded(ipProxySectionExpanded);
|
||
if (typeof updateIpProxyUI === 'function') {
|
||
updateIpProxyUI(latestState);
|
||
}
|
||
}
|
||
|
||
function toggleIpProxySectionExpanded() {
|
||
setIpProxySectionExpanded(!ipProxySectionExpanded);
|
||
}
|
||
|
||
function initIpProxySectionExpandedState() {
|
||
ipProxySectionExpanded = readIpProxySectionExpanded();
|
||
if (typeof updateIpProxyUI === 'function') {
|
||
updateIpProxyUI(latestState);
|
||
}
|
||
}
|
||
|
||
function normalizeIpProxyActionType(value = '') {
|
||
const normalized = String(value || '').trim().toLowerCase();
|
||
return normalized || 'action';
|
||
}
|
||
|
||
function getIpProxyActionLabel(action = '') {
|
||
const normalized = normalizeIpProxyActionType(action);
|
||
if (normalized === 'refresh') return '同步代理';
|
||
if (normalized === 'next') return '切换代理';
|
||
if (normalized === 'change') return '会话换出口';
|
||
if (normalized === 'probe') return '检测出口';
|
||
return '代理操作';
|
||
}
|
||
|
||
function isIpProxyActionBusy() {
|
||
return Boolean(ipProxyActionState.busy);
|
||
}
|
||
|
||
function getIpProxyActionState() {
|
||
return {
|
||
busy: Boolean(ipProxyActionState.busy),
|
||
action: normalizeIpProxyActionType(ipProxyActionState.action),
|
||
startedAt: Number(ipProxyActionState.startedAt) || 0,
|
||
};
|
||
}
|
||
|
||
function setIpProxyActionBusy(action = '', busy = false) {
|
||
ipProxyActionState.busy = Boolean(busy);
|
||
ipProxyActionState.action = ipProxyActionState.busy ? normalizeIpProxyActionType(action) : '';
|
||
ipProxyActionState.startedAt = ipProxyActionState.busy ? Date.now() : 0;
|
||
}
|
||
|
||
async function runIpProxyActionWithLock(action = '', runner) {
|
||
if (typeof runner !== 'function') {
|
||
throw new Error('代理操作执行器无效。');
|
||
}
|
||
const nextAction = normalizeIpProxyActionType(action);
|
||
const currentState = getIpProxyActionState();
|
||
if (currentState.busy) {
|
||
if (typeof showToast === 'function') {
|
||
showToast(`${getIpProxyActionLabel(currentState.action)}进行中，请稍候。`, 'info', 1600);
|
||
}
|
||
return { skipped: true };
|
||
}
|
||
|
||
setIpProxyActionBusy(nextAction, true);
|
||
if (typeof updateIpProxyUI === 'function') {
|
||
updateIpProxyUI(latestState);
|
||
}
|
||
|
||
const actionLabel = getIpProxyActionLabel(nextAction);
|
||
const timeoutMs = Math.max(5000, Number(IP_PROXY_ACTION_LOCK_TIMEOUT_MS) || 25000);
|
||
let timeoutId = 0;
|
||
try {
|
||
const value = await Promise.race([
|
||
Promise.resolve().then(() => runner()),
|
||
new Promise((_, reject) => {
|
||
timeoutId = globalThis.setTimeout(() => {
|
||
reject(new Error(`${actionLabel}超时（${Math.round(timeoutMs / 1000)} 秒），已自动解锁，请重试。`));
|
||
}, timeoutMs);
|
||
}),
|
||
]);
|
||
return { skipped: false, value };
|
||
} finally {
|
||
if (timeoutId) {
|
||
globalThis.clearTimeout(timeoutId);
|
||
}
|
||
setIpProxyActionBusy(nextAction, false);
|
||
if (typeof updateIpProxyUI === 'function') {
|
||
updateIpProxyUI(latestState);
|
||
}
|
||
}
|
||
}
|
||
|
||
function scheduleIpProxyExitProbe(options = {}) {
|
||
const {
|
||
silent = true,
|
||
delayMs = 80,
|
||
} = options;
|
||
const delay = Math.max(0, Number(delayMs) || 0);
|
||
if (ipProxyDeferredProbeTimer) {
|
||
globalThis.clearTimeout(ipProxyDeferredProbeTimer);
|
||
ipProxyDeferredProbeTimer = 0;
|
||
}
|
||
ipProxyDeferredProbeTimer = globalThis.setTimeout(() => {
|
||
ipProxyDeferredProbeTimer = 0;
|
||
Promise.resolve()
|
||
.then(() => probeIpProxyExit({ silent }))
|
||
.catch(() => {});
|
||
}, delay);
|
||
}
|
||
|
||
function normalizeIpProxyMode(value = '') {
|
||
const normalized = String(value || '').trim().toLowerCase();
|
||
return SUPPORTED_IP_PROXY_MODES.includes(normalized) ? normalized : DEFAULT_IP_PROXY_MODE;
|
||
}
|
||
|
||
function isIpProxyApiModeAvailable() {
|
||
return Boolean(typeof IP_PROXY_API_MODE_ENABLED === 'undefined'
|
||
? false
|
||
: IP_PROXY_API_MODE_ENABLED);
|
||
}
|
||
|
||
function isIpProxyAccountListAvailable() {
|
||
return Boolean(typeof IP_PROXY_ACCOUNT_LIST_ENABLED === 'undefined'
|
||
? true
|
||
: IP_PROXY_ACCOUNT_LIST_ENABLED);
|
||
}
|
||
|
||
function normalizeIpProxyModeForCurrentRelease(value = '') {
|
||
const normalized = normalizeIpProxyMode(value);
|
||
if (!isIpProxyApiModeAvailable() && normalized === 'api') {
|
||
return 'account';
|
||
}
|
||
return normalized;
|
||
}
|
||
|
||
function normalizeIpProxyProtocol(value = '') {
|
||
const normalized = String(value || '').trim().toLowerCase();
|
||
return SUPPORTED_IP_PROXY_PROTOCOLS.includes(normalized) ? normalized : DEFAULT_IP_PROXY_PROTOCOL;
|
||
}
|
||
|
||
function normalizeIpProxyPort(value = '') {
|
||
const numeric = Number.parseInt(String(value || '').trim(), 10);
|
||
if (!Number.isInteger(numeric) || numeric <= 0 || numeric > 65535) {
|
||
return 0;
|
||
}
|
||
return numeric;
|
||
}
|
||
|
||
function normalizeIpProxyPoolTargetCount(value = '', fallback = 20) {
|
||
const rawValue = String(value ?? '').trim();
|
||
if (!rawValue) {
|
||
return String(Math.max(1, Math.min(500, Number(fallback) || 20)));
|
||
}
|
||
const numeric = Number.parseInt(rawValue, 10);
|
||
if (!Number.isInteger(numeric)) {
|
||
return String(Math.max(1, Math.min(500, Number(fallback) || 20)));
|
||
}
|
||
return String(Math.max(1, Math.min(500, numeric)));
|
||
}
|
||
|
||
function normalizeIpProxyAccountLifeMinutes(value = '', fallback = '') {
|
||
const rawValue = String(value ?? '').trim();
|
||
if (!rawValue) {
|
||
return String(fallback || '').trim();
|
||
}
|
||
const numeric = Number.parseInt(rawValue, 10);
|
||
if (!Number.isInteger(numeric)) {
|
||
return String(fallback || '').trim();
|
||
}
|
||
return String(Math.max(1, Math.min(1440, numeric)));
|
||
}
|
||
|
||
function normalizeIpProxyAccountSessionPrefix(value = '') {
|
||
return String(value || '').trim().replace(/[^A-Za-z0-9_-]/g, '').slice(0, 32);
|
||
}
|
||
|
||
function normalizeIpProxyAccountList(value = '') {
|
||
return String(value || '')
|
||
.replace(/\r/g, '')
|
||
.split('\n')
|
||
.map((line) => line.trim())
|
||
.filter((line) => {
|
||
if (!line) {
|
||
return false;
|
||
}
|
||
// 与后台保持一致：支持 # / // / ; 注释行，注释行不参与生效。
|
||
if (/^(?:#|\/\/|;)/.test(line)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
})
|
||
.join('\n');
|
||
}
|
||
|
||
function normalizeIpProxyServiceProfile(rawValue = {}) {
|
||
const raw = (rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue))
|
||
? rawValue
|
||
: {};
|
||
return {
|
||
mode: normalizeIpProxyModeForCurrentRelease(raw.mode),
|
||
apiUrl: String(raw.apiUrl || '').trim(),
|
||
accountList: normalizeIpProxyAccountList(raw.accountList || ''),
|
||
accountSessionPrefix: normalizeIpProxyAccountSessionPrefix(raw.accountSessionPrefix || ''),
|
||
accountLifeMinutes: normalizeIpProxyAccountLifeMinutes(raw.accountLifeMinutes || ''),
|
||
poolTargetCount: normalizeIpProxyPoolTargetCount(raw.poolTargetCount || '', 20),
|
||
autoSyncEnabled: Boolean(raw.autoSyncEnabled),
|
||
autoSyncIntervalMinutes: String(Math.max(1, Math.min(1440, Number.parseInt(String(raw.autoSyncIntervalMinutes ?? '').trim(), 10) || 15))),
|
||
host: String(raw.host || '').trim(),
|
||
port: String(normalizeIpProxyPort(raw.port || '') || ''),
|
||
protocol: normalizeIpProxyProtocol(raw.protocol),
|
||
username: String(raw.username || '').trim(),
|
||
password: String(raw.password || ''),
|
||
region: String(raw.region || '').trim(),
|
||
};
|
||
}
|
||
|
||
function buildIpProxyServiceProfileFromFlatState(state = {}) {
|
||
return normalizeIpProxyServiceProfile({
|
||
mode: state?.ipProxyMode,
|
||
apiUrl: state?.ipProxyApiUrl,
|
||
accountList: state?.ipProxyAccountList,
|
||
accountSessionPrefix: state?.ipProxyAccountSessionPrefix,
|
||
accountLifeMinutes: state?.ipProxyAccountLifeMinutes,
|
||
poolTargetCount: state?.ipProxyPoolTargetCount,
|
||
autoSyncEnabled: state?.ipProxyAutoSyncEnabled,
|
||
autoSyncIntervalMinutes: state?.ipProxyAutoSyncIntervalMinutes,
|
||
host: state?.ipProxyHost,
|
||
port: state?.ipProxyPort,
|
||
protocol: state?.ipProxyProtocol,
|
||
username: state?.ipProxyUsername,
|
||
password: state?.ipProxyPassword,
|
||
region: state?.ipProxyRegion,
|
||
});
|
||
}
|
||
|
||
function normalizeIpProxyServiceProfiles(rawValue = {}, fallbackState = {}) {
|
||
const raw = (rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue))
|
||
? rawValue
|
||
: {};
|
||
const fallbackProfile = buildIpProxyServiceProfileFromFlatState(fallbackState);
|
||
const result = {};
|
||
SUPPORTED_IP_PROXY_SERVICES.forEach((service) => {
|
||
const serviceRaw = raw[service];
|
||
if (serviceRaw && typeof serviceRaw === 'object' && !Array.isArray(serviceRaw)) {
|
||
result[service] = normalizeIpProxyServiceProfile(serviceRaw);
|
||
return;
|
||
}
|
||
result[service] = normalizeIpProxyServiceProfile(fallbackProfile);
|
||
});
|
||
return result;
|
||
}
|
||
|
||
function getIpProxyServiceProfilesFromState(state = latestState) {
|
||
return normalizeIpProxyServiceProfiles(state?.ipProxyServiceProfiles || {}, state || {});
|
||
}
|
||
|
||
function getIpProxyServiceProfile(service = '', state = latestState) {
|
||
const selectedService = normalizeIpProxyService(service || state?.ipProxyService || DEFAULT_IP_PROXY_SERVICE);
|
||
const profiles = getIpProxyServiceProfilesFromState(state);
|
||
const profile = normalizeIpProxyServiceProfile(profiles[selectedService] || {});
|
||
const resolvedRegion = resolveIpProxyRegionFromInputs({
|
||
service: selectedService,
|
||
mode: profile.mode,
|
||
host: profile.host,
|
||
username: profile.username,
|
||
region: profile.region,
|
||
});
|
||
if (resolvedRegion) {
|
||
profile.region = resolvedRegion;
|
||
}
|
||
return profile;
|
||
}
|
||
|
||
function inferRegionFromProxyUsernameForPanel(username = '') {
|
||
const text = String(username || '').trim();
|
||
if (!text) return '';
|
||
const match = text.match(/(?:^|[-_])(?:region|area|country)[-_:]?([A-Za-z]{2})\b/i);
|
||
if (!match) return '';
|
||
return String(match[1] || '').trim().toUpperCase();
|
||
}
|
||
|
||
function inferRegionFromProxyHostForPanel(host = '') {
|
||
const text = String(host || '').trim().toLowerCase().replace(/\.$/, '');
|
||
if (!text || !text.includes('.')) return '';
|
||
const firstLabel = String(text.split('.')[0] || '').trim();
|
||
if (!/^[a-z]{2}$/.test(firstLabel)) return '';
|
||
return firstLabel.toUpperCase();
|
||
}
|
||
|
||
function normalizeExplicitRegionForPanel(region = '') {
|
||
const text = String(region || '').trim().toUpperCase().replace(/[^A-Z]/g, '');
|
||
return /^[A-Z]{2}$/.test(text) ? text : '';
|
||
}
|
||
|
||
function resolveIpProxyRegionFromInputs(options = {}) {
|
||
const selectedService = normalizeIpProxyService(options?.service || DEFAULT_IP_PROXY_SERVICE);
|
||
const selectedMode = normalizeIpProxyModeForCurrentRelease(options?.mode || DEFAULT_IP_PROXY_MODE);
|
||
if (selectedMode !== 'account') {
|
||
return '';
|
||
}
|
||
|
||
const host = String(options?.host || '').trim();
|
||
const username = String(options?.username || '').trim();
|
||
const region = String(options?.region || '').trim();
|
||
if (selectedService === '711proxy') {
|
||
const resolvedCode = typeof resolve711ProxyRegionFromInputs === 'function'
|
||
? resolve711ProxyRegionFromInputs({ host, username, region })
|
||
: '';
|
||
if (resolvedCode) {
|
||
return String(resolvedCode || '').trim().toUpperCase();
|
||
}
|
||
}
|
||
|
||
const fromUsername = inferRegionFromProxyUsernameForPanel(username);
|
||
if (fromUsername) {
|
||
return fromUsername;
|
||
}
|
||
const fromHost = inferRegionFromProxyHostForPanel(host);
|
||
if (fromHost) {
|
||
return fromHost;
|
||
}
|
||
return normalizeExplicitRegionForPanel(region);
|
||
}
|
||
|
||
function hasCurrentInputAccountListEntries() {
|
||
if (!isIpProxyAccountListAvailable()) {
|
||
return false;
|
||
}
|
||
return normalizeIpProxyAccountList(inputIpProxyAccountList?.value || '')
|
||
.split('\n')
|
||
.map((line) => line.trim())
|
||
.filter(Boolean)
|
||
.length > 0;
|
||
}
|
||
|
||
function syncIpProxyRegionInputFromCredentials(options = {}) {
|
||
if (!inputIpProxyRegion) {
|
||
return '';
|
||
}
|
||
const selectedService = normalizeIpProxyService(
|
||
selectIpProxyService?.value || latestState?.ipProxyService || DEFAULT_IP_PROXY_SERVICE
|
||
);
|
||
const selectedMode = normalizeIpProxyModeForCurrentRelease(getSelectedIpProxyMode());
|
||
if (selectedMode !== 'account' || hasCurrentInputAccountListEntries()) {
|
||
return '';
|
||
}
|
||
const force = Boolean(options?.force);
|
||
const currentRegion = String(inputIpProxyRegion.value || '').trim();
|
||
const resolvedRegion = resolveIpProxyRegionFromInputs({
|
||
service: selectedService,
|
||
mode: selectedMode,
|
||
host: inputIpProxyHost?.value || '',
|
||
username: inputIpProxyUsername?.value || '',
|
||
region: currentRegion,
|
||
});
|
||
if (!resolvedRegion) {
|
||
return '';
|
||
}
|
||
const normalizedCurrent = normalizeExplicitRegionForPanel(currentRegion);
|
||
if (force || !normalizedCurrent) {
|
||
inputIpProxyRegion.value = resolvedRegion;
|
||
}
|
||
return resolvedRegion;
|
||
}
|
||
|
||
function buildCurrentIpProxyServiceProfileFromInputs() {
|
||
const selectedService = normalizeIpProxyService(
|
||
selectIpProxyService?.value || latestState?.ipProxyService || DEFAULT_IP_PROXY_SERVICE
|
||
);
|
||
const selectedMode = normalizeIpProxyMode(getSelectedIpProxyMode());
|
||
const effectiveMode = normalizeIpProxyModeForCurrentRelease(selectedMode);
|
||
const rawRegion = String(inputIpProxyRegion?.value || '').trim();
|
||
const finalRegion = resolveIpProxyRegionFromInputs({
|
||
service: selectedService,
|
||
mode: effectiveMode,
|
||
host: inputIpProxyHost?.value || '',
|
||
username: inputIpProxyUsername?.value || '',
|
||
region: rawRegion,
|
||
}) || rawRegion;
|
||
return normalizeIpProxyServiceProfile({
|
||
mode: effectiveMode,
|
||
apiUrl: inputIpProxyApiUrl?.value || '',
|
||
accountList: isIpProxyAccountListAvailable() ? (inputIpProxyAccountList?.value || '') : '',
|
||
accountSessionPrefix: inputIpProxyAccountSessionPrefix?.value || '',
|
||
accountLifeMinutes: inputIpProxyAccountLifeMinutes?.value || '',
|
||
poolTargetCount: inputIpProxyPoolTargetCount?.value || '',
|
||
autoSyncEnabled: Boolean(inputIpProxyAutoSyncEnabled?.checked),
|
||
autoSyncIntervalMinutes: inputIpProxyAutoSyncIntervalMinutes?.value || '',
|
||
host: inputIpProxyHost?.value || '',
|
||
port: inputIpProxyPort?.value || '',
|
||
protocol: selectIpProxyProtocol?.value || '',
|
||
username: inputIpProxyUsername?.value || '',
|
||
password: inputIpProxyPassword?.value || '',
|
||
region: finalRegion,
|
||
});
|
||
}
|
||
|
||
function buildIpProxyServiceProfilesPatch(selectedService = '', state = latestState) {
|
||
const nextService = normalizeIpProxyService(
|
||
selectedService
|
||
|| selectIpProxyService?.value
|
||
|| state?.ipProxyService
|
||
|| DEFAULT_IP_PROXY_SERVICE
|
||
);
|
||
const profiles = getIpProxyServiceProfilesFromState(state || {});
|
||
profiles[nextService] = buildCurrentIpProxyServiceProfileFromInputs();
|
||
return normalizeIpProxyServiceProfiles(profiles, state || {});
|
||
}
|
||
|
||
function buildIpProxyStatePatchFromServiceProfile(service = '', profile = {}) {
|
||
const normalizedService = normalizeIpProxyService(service || DEFAULT_IP_PROXY_SERVICE);
|
||
const normalizedProfile = normalizeIpProxyServiceProfile(profile);
|
||
return {
|
||
ipProxyService: normalizedService,
|
||
ipProxyMode: normalizedProfile.mode,
|
||
ipProxyApiUrl: normalizedProfile.apiUrl,
|
||
ipProxyAccountList: normalizedProfile.accountList,
|
||
ipProxyAccountSessionPrefix: normalizedProfile.accountSessionPrefix,
|
||
ipProxyAccountLifeMinutes: normalizedProfile.accountLifeMinutes,
|
||
ipProxyPoolTargetCount: normalizedProfile.poolTargetCount,
|
||
ipProxyAutoSyncEnabled: normalizedProfile.autoSyncEnabled,
|
||
ipProxyAutoSyncIntervalMinutes: Number.parseInt(String(normalizedProfile.autoSyncIntervalMinutes || '15').trim(), 10) || 15,
|
||
ipProxyHost: normalizedProfile.host,
|
||
ipProxyPort: normalizedProfile.port,
|
||
ipProxyProtocol: normalizedProfile.protocol,
|
||
ipProxyUsername: normalizedProfile.username,
|
||
ipProxyPassword: normalizedProfile.password,
|
||
ipProxyRegion: normalizedProfile.region,
|
||
};
|
||
}
|
||
|
||
function applyIpProxyServiceProfileToInputs(profile = {}, options = {}) {
|
||
const { keepMode = false } = options;
|
||
const normalizedProfile = normalizeIpProxyServiceProfile(profile);
|
||
if (!keepMode) {
|
||
setIpProxyMode(normalizedProfile.mode);
|
||
}
|
||
if (inputIpProxyApiUrl) {
|
||
inputIpProxyApiUrl.value = normalizedProfile.apiUrl;
|
||
}
|
||
if (inputIpProxyAccountList) {
|
||
inputIpProxyAccountList.value = normalizedProfile.accountList;
|
||
}
|
||
if (inputIpProxyAccountSessionPrefix) {
|
||
inputIpProxyAccountSessionPrefix.value = normalizedProfile.accountSessionPrefix;
|
||
}
|
||
if (inputIpProxyAccountLifeMinutes) {
|
||
inputIpProxyAccountLifeMinutes.value = normalizedProfile.accountLifeMinutes;
|
||
}
|
||
if (inputIpProxyPoolTargetCount) {
|
||
inputIpProxyPoolTargetCount.value = normalizedProfile.poolTargetCount;
|
||
}
|
||
if (inputIpProxyAutoSyncEnabled) {
|
||
inputIpProxyAutoSyncEnabled.checked = Boolean(normalizedProfile.autoSyncEnabled);
|
||
}
|
||
if (inputIpProxyAutoSyncIntervalMinutes) {
|
||
inputIpProxyAutoSyncIntervalMinutes.value = String(normalizedProfile.autoSyncIntervalMinutes || '15');
|
||
}
|
||
if (inputIpProxyHost) {
|
||
inputIpProxyHost.value = normalizedProfile.host;
|
||
}
|
||
if (inputIpProxyPort) {
|
||
inputIpProxyPort.value = normalizedProfile.port;
|
||
}
|
||
if (selectIpProxyProtocol) {
|
||
selectIpProxyProtocol.value = normalizedProfile.protocol;
|
||
}
|
||
if (inputIpProxyUsername) {
|
||
inputIpProxyUsername.value = normalizedProfile.username;
|
||
}
|
||
if (inputIpProxyPassword) {
|
||
inputIpProxyPassword.value = normalizedProfile.password;
|
||
}
|
||
if (inputIpProxyRegion) {
|
||
inputIpProxyRegion.value = normalizedProfile.region;
|
||
}
|
||
}
|
||
|
||
function getSelectedIpProxyEnabled() {
|
||
if (inputIpProxyEnabled) {
|
||
return Boolean(inputIpProxyEnabled.checked);
|
||
}
|
||
const activeButton = ipProxyEnabledButtons.find((button) => button.classList.contains('is-active'));
|
||
return String(activeButton?.dataset?.ipProxyEnabled) === 'true';
|
||
}
|
||
|
||
function setIpProxyEnabled(enabled) {
|
||
const nextEnabled = Boolean(enabled);
|
||
if (inputIpProxyEnabled) {
|
||
inputIpProxyEnabled.checked = nextEnabled;
|
||
}
|
||
ipProxyEnabledButtons.forEach((button) => {
|
||
const buttonValue = String(button?.dataset?.ipProxyEnabled) === 'true';
|
||
button.classList.toggle('is-active', buttonValue === nextEnabled);
|
||
button.setAttribute('aria-pressed', String(buttonValue === nextEnabled));
|
||
});
|
||
}
|
||
|
||
function getSelectedIpProxyMode() {
|
||
const activeButton = ipProxyModeButtons.find((button) => button.classList.contains('is-active'));
|
||
return normalizeIpProxyModeForCurrentRelease(activeButton?.dataset?.ipProxyMode || DEFAULT_IP_PROXY_MODE);
|
||
}
|
||
|
||
function setIpProxyMode(mode) {
|
||
const nextMode = normalizeIpProxyModeForCurrentRelease(mode);
|
||
ipProxyModeButtons.forEach((button) => {
|
||
const buttonMode = normalizeIpProxyMode(button?.dataset?.ipProxyMode || DEFAULT_IP_PROXY_MODE);
|
||
button.classList.toggle('is-active', buttonMode === nextMode);
|
||
button.setAttribute('aria-pressed', String(buttonMode === nextMode));
|
||
});
|
||
}
|
||
|
||
function getIpProxyRuntimeFieldNames(mode = DEFAULT_IP_PROXY_MODE) {
|
||
const normalizedMode = normalizeIpProxyModeForCurrentRelease(mode);
|
||
if (normalizedMode === 'account') {
|
||
return {
|
||
poolKey: 'ipProxyAccountPool',
|
||
indexKey: 'ipProxyAccountCurrentIndex',
|
||
currentKey: 'ipProxyAccountCurrent',
|
||
};
|
||
}
|
||
return {
|
||
poolKey: 'ipProxyApiPool',
|
||
indexKey: 'ipProxyApiCurrentIndex',
|
||
currentKey: 'ipProxyApiCurrent',
|
||
};
|
||
}
|
||
|
||
function getIpProxyRuntimeSnapshot(state = latestState, mode = normalizeIpProxyModeForCurrentRelease(state?.ipProxyMode)) {
|
||
const normalizedMode = normalizeIpProxyModeForCurrentRelease(mode);
|
||
const fields = getIpProxyRuntimeFieldNames(normalizedMode);
|
||
const hasAccountListConfigured = normalizedMode === 'account'
|
||
&& normalizeIpProxyAccountList(state?.ipProxyAccountList || '').split('\n').filter(Boolean).length > 0;
|
||
const hasModePool = Array.isArray(state?.[fields.poolKey]);
|
||
const hasModeCurrent = state?.[fields.currentKey] !== undefined && state?.[fields.currentKey] !== null;
|
||
const hasModeIndex = state?.[fields.indexKey] !== undefined && state?.[fields.indexKey] !== null;
|
||
const modePool = Array.isArray(state?.[fields.poolKey]) ? state[fields.poolKey] : [];
|
||
// 账号模式在“固定账号”场景下不应读取历史 runtime 缓存，否则会出现
|
||
// “状态显示 A 节点、当前节点显示 B 节点”的错位。
|
||
const allowAccountRuntimeCache = normalizedMode !== 'account' || hasAccountListConfigured;
|
||
const pool = hasModePool && allowAccountRuntimeCache ? modePool : [];
|
||
const current = hasModeCurrent && allowAccountRuntimeCache ? state?.[fields.currentKey] : null;
|
||
const rawIndex = hasModeIndex && allowAccountRuntimeCache ? state?.[fields.indexKey] : 0;
|
||
const index = Number.isFinite(Number(rawIndex)) ? Math.max(0, Math.floor(Number(rawIndex))) : 0;
|
||
return {
|
||
mode: normalizedMode,
|
||
...fields,
|
||
hasModePool: hasModePool && allowAccountRuntimeCache,
|
||
hasModeCurrent: hasModeCurrent && allowAccountRuntimeCache,
|
||
hasModeIndex: hasModeIndex && allowAccountRuntimeCache,
|
||
hasAccountListConfigured,
|
||
pool,
|
||
current,
|
||
index,
|
||
};
|
||
}
|
||
|
||
function buildIpProxyRuntimeStatePatchForMode(mode = DEFAULT_IP_PROXY_MODE, response = {}) {
|
||
const normalizedMode = normalizeIpProxyModeForCurrentRelease(mode);
|
||
const fields = getIpProxyRuntimeFieldNames(normalizedMode);
|
||
const patch = {};
|
||
if (response?.pool !== undefined) {
|
||
patch[fields.poolKey] = Array.isArray(response.pool) ? response.pool : [];
|
||
// 兼容旧字段：始终反映当前激活模式的运行态。
|
||
patch.ipProxyPool = patch[fields.poolKey];
|
||
}
|
||
if (response?.index !== undefined) {
|
||
const index = Number.isFinite(Number(response.index)) ? Math.max(0, Math.floor(Number(response.index))) : 0;
|
||
patch[fields.indexKey] = index;
|
||
patch.ipProxyCurrentIndex = index;
|
||
}
|
||
if (response?.current !== undefined) {
|
||
patch[fields.currentKey] = response.current || null;
|
||
patch.ipProxyCurrent = response.current || null;
|
||
}
|
||
return patch;
|
||
}
|
||
|
||
function getIpProxyCurrentEntry(state = latestState) {
|
||
const mode = normalizeIpProxyModeForCurrentRelease(state?.ipProxyMode);
|
||
if (mode === 'account') {
|
||
const runtime = getIpProxyRuntimeSnapshot(state, mode);
|
||
const poolEntry = runtime.hasModePool && runtime.pool.length
|
||
? runtime.pool[runtime.index % runtime.pool.length]
|
||
: null;
|
||
const modeCurrent = runtime.hasModeCurrent ? runtime.current : null;
|
||
const hasRuntimeEntry = Boolean(poolEntry || modeCurrent);
|
||
const current = poolEntry || modeCurrent || {};
|
||
const host = String(current?.host || state?.ipProxyHost || '').trim();
|
||
const port = Number(current?.port || normalizeIpProxyPort(state?.ipProxyPort));
|
||
if (!host || !Number.isInteger(port) || port <= 0 || port > 65535) {
|
||
return null;
|
||
}
|
||
return {
|
||
host,
|
||
port,
|
||
username: hasRuntimeEntry
|
||
? String(current?.username || '').trim()
|
||
: String(current?.username || state?.ipProxyUsername || '').trim(),
|
||
password: hasRuntimeEntry
|
||
? String(current?.password || '')
|
||
: String(current?.password || state?.ipProxyPassword || ''),
|
||
protocol: normalizeIpProxyProtocol(current?.protocol || state?.ipProxyProtocol),
|
||
region: hasRuntimeEntry
|
||
? String(current?.region || '').trim()
|
||
: String(current?.region || state?.ipProxyRegion || '').trim(),
|
||
provider: normalizeIpProxyService(state?.ipProxyService),
|
||
};
|
||
}
|
||
|
||
const runtime = getIpProxyRuntimeSnapshot(state, mode);
|
||
if (runtime.pool.length) {
|
||
const index = runtime.index % runtime.pool.length;
|
||
const current = runtime.pool[index];
|
||
if (current?.host && current?.port) {
|
||
return current;
|
||
}
|
||
}
|
||
const current = runtime.current;
|
||
return current && current.host && current.port ? current : null;
|
||
}
|
||
|
||
function has711SessionTokenForPanel(username = '') {
|
||
const text = String(username || '').trim();
|
||
if (!text) {
|
||
return false;
|
||
}
|
||
return /(?:^|[-_])session[-_:][A-Za-z0-9_-]+?(?=(?:[-_](?:sessTime|sessAuto|region|life|zone|ptype|country|area)\b)|$)/i.test(text);
|
||
}
|
||
|
||
function normalize711SessionIdForPanel(value = '') {
|
||
return String(value || '').trim().replace(/[^A-Za-z0-9_-]/g, '').slice(0, 64);
|
||
}
|
||
|
||
function normalize711SessTimeForPanel(value = '') {
|
||
const raw = String(value ?? '').trim();
|
||
if (!raw) {
|
||
return '';
|
||
}
|
||
const numeric = Number.parseInt(raw, 10);
|
||
if (!Number.isInteger(numeric)) {
|
||
return '';
|
||
}
|
||
return String(Math.max(1, Math.min(180, numeric)));
|
||
}
|
||
|
||
function normalize711RegionCodeForPanel(value = '') {
|
||
const text = String(value || '').trim().toUpperCase().replace(/[^A-Z]/g, '');
|
||
return /^[A-Z]{2}$/.test(text) ? text : '';
|
||
}
|
||
|
||
function shouldAutoSync711SessionFieldsForPanel(state = latestState) {
|
||
const service = normalizeIpProxyService(
|
||
selectIpProxyService?.value || state?.ipProxyService || DEFAULT_IP_PROXY_SERVICE
|
||
);
|
||
const mode = normalizeIpProxyModeForCurrentRelease(getSelectedIpProxyMode());
|
||
if (service !== '711proxy' || mode !== 'account') {
|
||
return false;
|
||
}
|
||
return !hasCurrentInputAccountListEntries();
|
||
}
|
||
|
||
function parse711RegionFromUsernameForPanel(username = '') {
|
||
const text = String(username || '').trim();
|
||
if (!text) {
|
||
return '';
|
||
}
|
||
const match = text.match(/(?:^|[-_])region[-_:]?([A-Za-z]{2})\b/i);
|
||
return normalize711RegionCodeForPanel(match ? match[1] : '');
|
||
}
|
||
|
||
function apply711RegionToUsernameForPanel(username = '', regionCode = '', options = {}) {
|
||
const text = String(username || '').trim();
|
||
if (!text) {
|
||
return '';
|
||
}
|
||
|
||
const normalizedRegion = normalize711RegionCodeForPanel(regionCode);
|
||
const removeWhenEmpty = Boolean(options?.removeWhenEmpty);
|
||
|
||
if (normalizedRegion) {
|
||
if (/(?:^|[-_])region[-_:]?[A-Za-z]{2}\b/i.test(text)) {
|
||
return text.replace(/((?:^|[-_])region[-_:]?)([A-Za-z]{2})\b/i, `$1${normalizedRegion}`);
|
||
}
|
||
return `${text}-region-${normalizedRegion}`;
|
||
}
|
||
|
||
if (!removeWhenEmpty) {
|
||
return text;
|
||
}
|
||
|
||
return String(text.replace(/(^|[-_])region[-_:]?[A-Za-z]{2}\b/ig, '$1') || '')
|
||
.replace(/[-_]{2,}/g, '-')
|
||
.replace(/^[-_]+|[-_]+$/g, '')
|
||
.trim();
|
||
}
|
||
|
||
function parse711SessionConfigFromUsernameForPanel(username = '') {
|
||
const text = String(username || '').trim();
|
||
if (!text) {
|
||
return { sessionId: '', sessTime: '' };
|
||
}
|
||
const sessionMatch = text.match(/(?:^|[-_])session[-_:]([A-Za-z0-9_-]+?)(?=(?:[-_](?:sessTime|sessAuto|region|life|zone|ptype|country|area)\b)|$)/i);
|
||
const sessTimeMatch = text.match(/(?:^|[-_])sessTime[-_:]?(\d+)\b/i);
|
||
const lifeMatch = text.match(/(?:^|[-_])life[-_:]?(\d+)\b/i);
|
||
return {
|
||
sessionId: normalize711SessionIdForPanel(sessionMatch ? sessionMatch[1] : ''),
|
||
sessTime: normalize711SessTimeForPanel(
|
||
sessTimeMatch ? sessTimeMatch[1] : (lifeMatch ? lifeMatch[1] : '')
|
||
),
|
||
};
|
||
}
|
||
|
||
function apply711SessionConfigToUsernameForPanel(username = '', options = {}) {
|
||
const text = String(username || '').trim();
|
||
if (!text) {
|
||
return '';
|
||
}
|
||
|
||
const sessionId = normalize711SessionIdForPanel(options?.sessionId || '');
|
||
const sessTime = normalize711SessTimeForPanel(options?.sessTime || '');
|
||
const removeWhenEmpty = Boolean(options?.removeWhenEmpty);
|
||
let next = text;
|
||
|
||
if (sessionId) {
|
||
if (/(?:^|[-_])session[-_:][A-Za-z0-9_-]+?(?=(?:[-_](?:sessTime|sessAuto|region|life|zone|ptype|country|area)\b)|$)/i.test(next)) {
|
||
next = next.replace(
|
||
/((?:^|[-_])session[-_:])([A-Za-z0-9_-]+?)(?=(?:[-_](?:sessTime|sessAuto|region|life|zone|ptype|country|area)\b)|$)/i,
|
||
`$1${sessionId}`
|
||
);
|
||
} else {
|
||
next = `${next}-session-${sessionId}`;
|
||
}
|
||
} else if (removeWhenEmpty) {
|
||
next = next.replace(
|
||
/(^|[-_])session[-_:][A-Za-z0-9_-]+?(?=(?:[-_](?:sessTime|sessAuto|region|life|zone|ptype|country|area)\b)|$)/ig,
|
||
'$1'
|
||
);
|
||
}
|
||
|
||
if (sessTime) {
|
||
if (/(?:^|[-_])sessTime[-_:]?\d+\b/i.test(next)) {
|
||
next = next.replace(/((?:^|[-_])sessTime[-_:]?)(\d+)\b/i, `$1${sessTime}`);
|
||
} else if (/(?:^|[-_])life[-_:]?\d+\b/i.test(next)) {
|
||
next = next.replace(/((?:^|[-_])life[-_:]?)(\d+)\b/i, `$1${sessTime}`);
|
||
} else {
|
||
next = `${next}-sessTime-${sessTime}`;
|
||
}
|
||
} else if (removeWhenEmpty) {
|
||
next = next.replace(/(^|[-_])sessTime[-_:]?\d+\b/ig, '$1');
|
||
next = next.replace(/(^|[-_])life[-_:]?\d+\b/ig, '$1');
|
||
}
|
||
|
||
return String(next || '')
|
||
.replace(/[-_]{2,}/g, '-')
|
||
.replace(/^[-_]+|[-_]+$/g, '')
|
||
.trim();
|
||
}
|
||
|
||
function sync711SessionFieldsFromUsernameForPanel(options = {}) {
|
||
if (!shouldAutoSync711SessionFieldsForPanel(options?.state || latestState)) {
|
||
return { updated: false, sessionId: '', sessTime: '' };
|
||
}
|
||
const username = String(
|
||
options?.username !== undefined
|
||
? options.username
|
||
: (inputIpProxyUsername?.value || '')
|
||
).trim();
|
||
if (!username) {
|
||
return { updated: false, sessionId: '', sessTime: '' };
|
||
}
|
||
|
||
const parsed = parse711SessionConfigFromUsernameForPanel(username);
|
||
let updated = false;
|
||
|
||
if (parsed.sessionId && inputIpProxyAccountSessionPrefix) {
|
||
const currentSession = normalizeIpProxyAccountSessionPrefix(
|
||
inputIpProxyAccountSessionPrefix.value || ''
|
||
);
|
||
if (currentSession !== parsed.sessionId) {
|
||
inputIpProxyAccountSessionPrefix.value = parsed.sessionId;
|
||
updated = true;
|
||
}
|
||
}
|
||
|
||
if (parsed.sessTime && inputIpProxyAccountLifeMinutes) {
|
||
const currentLife = normalizeIpProxyAccountLifeMinutes(
|
||
inputIpProxyAccountLifeMinutes.value || ''
|
||
);
|
||
if (currentLife !== parsed.sessTime) {
|
||
inputIpProxyAccountLifeMinutes.value = parsed.sessTime;
|
||
updated = true;
|
||
}
|
||
}
|
||
|
||
return {
|
||
updated,
|
||
sessionId: parsed.sessionId,
|
||
sessTime: parsed.sessTime,
|
||
};
|
||
}
|
||
|
||
function sync711RegionFieldFromUsernameForPanel(options = {}) {
|
||
if (!shouldAutoSync711SessionFieldsForPanel(options?.state || latestState)) {
|
||
return { updated: false, region: '' };
|
||
}
|
||
if (!inputIpProxyRegion) {
|
||
return { updated: false, region: '' };
|
||
}
|
||
|
||
const username = String(
|
||
options?.username !== undefined
|
||
? options.username
|
||
: (inputIpProxyUsername?.value || '')
|
||
).trim();
|
||
const parsedRegion = parse711RegionFromUsernameForPanel(username);
|
||
if (!parsedRegion) {
|
||
return { updated: false, region: '' };
|
||
}
|
||
|
||
const currentRegion = normalize711RegionCodeForPanel(inputIpProxyRegion.value || '');
|
||
if (currentRegion === parsedRegion) {
|
||
return { updated: false, region: parsedRegion };
|
||
}
|
||
inputIpProxyRegion.value = parsedRegion;
|
||
return { updated: true, region: parsedRegion };
|
||
}
|
||
|
||
function sync711UsernameFromSessionFieldsForPanel(options = {}) {
|
||
if (!shouldAutoSync711SessionFieldsForPanel(options?.state || latestState)) {
|
||
return { updated: false, username: '' };
|
||
}
|
||
if (!inputIpProxyUsername) {
|
||
return { updated: false, username: '' };
|
||
}
|
||
|
||
const currentUsername = String(inputIpProxyUsername.value || '').trim();
|
||
if (!currentUsername) {
|
||
return { updated: false, username: '' };
|
||
}
|
||
|
||
const sessionId = normalize711SessionIdForPanel(
|
||
options?.sessionId !== undefined
|
||
? options.sessionId
|
||
: (inputIpProxyAccountSessionPrefix?.value || '')
|
||
);
|
||
const lifeMinutes = normalizeIpProxyAccountLifeMinutes(
|
||
options?.sessTime !== undefined
|
||
? options.sessTime
|
||
: (inputIpProxyAccountLifeMinutes?.value || '')
|
||
);
|
||
const sessTime = normalize711SessTimeForPanel(lifeMinutes);
|
||
const nextUsername = apply711SessionConfigToUsernameForPanel(currentUsername, {
|
||
sessionId,
|
||
sessTime,
|
||
removeWhenEmpty: Boolean(options?.removeWhenEmpty),
|
||
});
|
||
|
||
if (!nextUsername || nextUsername === currentUsername) {
|
||
return { updated: false, username: currentUsername };
|
||
}
|
||
|
||
inputIpProxyUsername.value = nextUsername;
|
||
return { updated: true, username: nextUsername };
|
||
}
|
||
|
||
function sync711UsernameFromRegionForPanel(options = {}) {
|
||
if (!shouldAutoSync711SessionFieldsForPanel(options?.state || latestState)) {
|
||
return { updated: false, username: '' };
|
||
}
|
||
if (!inputIpProxyUsername) {
|
||
return { updated: false, username: '' };
|
||
}
|
||
|
||
const currentUsername = String(inputIpProxyUsername.value || '').trim();
|
||
if (!currentUsername) {
|
||
return { updated: false, username: '' };
|
||
}
|
||
|
||
const rawRegion = String(
|
||
options?.region !== undefined
|
||
? options.region
|
||
: (inputIpProxyRegion?.value || '')
|
||
).trim();
|
||
const normalizedRegion = normalize711RegionCodeForPanel(rawRegion);
|
||
const nextUsername = apply711RegionToUsernameForPanel(
|
||
currentUsername,
|
||
normalizedRegion,
|
||
{ removeWhenEmpty: Boolean(options?.removeWhenEmpty) }
|
||
);
|
||
|
||
if (!nextUsername || nextUsername === currentUsername) {
|
||
return { updated: false, username: currentUsername };
|
||
}
|
||
|
||
inputIpProxyUsername.value = nextUsername;
|
||
return { updated: true, username: nextUsername };
|
||
}
|
||
|
||
function canChangeIpProxyExitWithCurrentSession(state = latestState) {
|
||
const mode = getSelectedIpProxyMode();
|
||
const service = normalizeIpProxyService(
|
||
selectIpProxyService?.value || state?.ipProxyService || DEFAULT_IP_PROXY_SERVICE
|
||
);
|
||
if (mode !== 'account' || service !== '711proxy') {
|
||
return false;
|
||
}
|
||
const currentEntry = getIpProxyCurrentEntry(state);
|
||
const username = String(currentEntry?.username || inputIpProxyUsername?.value || '').trim();
|
||
return has711SessionTokenForPanel(username);
|
||
}
|
||
|
||
function buildIpProxyActionHintText(options = {}) {
|
||
const mode = normalizeIpProxyModeForCurrentRelease(options?.mode || DEFAULT_IP_PROXY_MODE);
|
||
const poolCount = Math.max(0, Number(options?.poolCount) || 0);
|
||
const changeAvailable = Boolean(options?.changeAvailable);
|
||
const dynamicPoolCount = poolCount > 0 ? poolCount : 1;
|
||
|
||
if (mode === 'api') {
|
||
const nextPart = poolCount > 1
|
||
? `下一条：当前共 ${dynamicPoolCount} 条节点，切到已拉取代理池的下一条节点。`
|
||
: `下一条：当前仅 ${dynamicPoolCount} 条节点，执行重绑复测（不保证更换出口）。`;
|
||
return `${nextPart} Change：仅账号模式可用。`;
|
||
}
|
||
|
||
const nextPart = poolCount > 1
|
||
? `下一条：当前共 ${dynamicPoolCount} 条节点，切到代理池的下一条节点。`
|
||
: `下一条：当前仅 ${dynamicPoolCount} 条节点，执行重绑复测（不保证更换出口）。`;
|
||
const changePart = changeAvailable
|
||
? 'Change：保持当前 session 重绑链路并复测出口。'
|
||
: 'Change：需 711 账号模式且用户名包含 session。';
|
||
return `${nextPart} ${changePart}`;
|
||
}
|
||
|
||
function setIpProxyCurrentDisplay(text = '', hasValue = false) {
|
||
if (!ipProxyCurrent) return;
|
||
ipProxyCurrent.textContent = text || '暂无可用代理';
|
||
ipProxyCurrent.title = text || '暂无可用代理';
|
||
ipProxyCurrent.classList.toggle('has-value', Boolean(hasValue));
|
||
}
|
||
|
||
function formatIpProxyCurrentDisplay(state = latestState) {
|
||
const mode = normalizeIpProxyModeForCurrentRelease(state?.ipProxyMode);
|
||
if (mode === 'account') {
|
||
const current = getIpProxyCurrentEntry(state);
|
||
if (!current) {
|
||
return {
|
||
text: '账号模式：请填写代理列表，或填写 Host / Port',
|
||
hasValue: false,
|
||
};
|
||
}
|
||
return {
|
||
text: `${current.host}:${current.port}${current.region ? ` [${current.region}]` : ''}`,
|
||
hasValue: true,
|
||
};
|
||
}
|
||
|
||
const runtime = getIpProxyRuntimeSnapshot(state, mode);
|
||
const current = getIpProxyCurrentEntry(state);
|
||
const count = runtime.pool.length;
|
||
const index = runtime.index;
|
||
if (!current) {
|
||
return {
|
||
text: count ? `已拉取 ${count} 条，点击“下一条”切换` : '暂无可用代理',
|
||
hasValue: false,
|
||
};
|
||
}
|
||
const region = String(current.region || '').trim();
|
||
const label = region ? `${current.host}:${current.port} [${region}]` : `${current.host}:${current.port}`;
|
||
return {
|
||
text: label,
|
||
hasValue: true,
|
||
};
|
||
}
|
||
|
||
function extractIpProxyEndpointToken(text = '') {
|
||
const raw = String(text || '').trim();
|
||
if (!raw) return '';
|
||
const match = raw.match(/^([^\s\[]+:\d+)/);
|
||
return match ? String(match[1]).toLowerCase() : '';
|
||
}
|
||
|
||
function extractIpProxyIndexToken(text = '') {
|
||
const raw = String(text || '').trim();
|
||
if (!raw) return '';
|
||
const match = raw.match(/\((\d+\s*\/\s*\d+)\)\s*$/);
|
||
if (!match) return '';
|
||
return String(match[1]).replace(/\s+/g, '');
|
||
}
|
||
|
||
function buildIpProxyCurrentDisplayText(display = {}, runtimeStatus = {}) {
|
||
const rawText = String(display?.text || '').trim();
|
||
const hasValue = Boolean(display?.hasValue);
|
||
if (!hasValue || !rawText) {
|
||
return rawText;
|
||
}
|
||
return rawText;
|
||
}
|
||
|
||
function formatIpProxyRuntimeStatus(state = latestState) {
|
||
const enabled = Boolean(state?.ipProxyEnabled);
|
||
const mode = normalizeIpProxyModeForCurrentRelease(state?.ipProxyMode);
|
||
const hasAccountListConfigured = mode === 'account'
|
||
&& normalizeIpProxyAccountList(state?.ipProxyAccountList || '').split('\n').filter(Boolean).length > 0;
|
||
const accountSourceTag = mode === 'account'
|
||
? (hasAccountListConfigured ? '（账号列表）' : '（固定账号）')
|
||
: '';
|
||
const accountSourceDetail = mode === 'account'
|
||
? (
|
||
hasAccountListConfigured
|
||
? '当前生效来源：账号列表（固定账号字段已忽略）。'
|
||
: '当前生效来源：固定账号字段。'
|
||
)
|
||
: '';
|
||
const activeEntry = getIpProxyCurrentEntry(state);
|
||
const applied = Boolean(state?.ipProxyApplied);
|
||
const reason = String(state?.ipProxyAppliedReason || '').trim().toLowerCase();
|
||
const host = String(
|
||
state?.ipProxyAppliedHost
|
||
|| activeEntry?.host
|
||
|| (mode === 'account' ? state?.ipProxyHost : '')
|
||
|| ''
|
||
).trim();
|
||
const portValue = Number(
|
||
state?.ipProxyAppliedPort
|
||
|| activeEntry?.port
|
||
|| (mode === 'account' ? normalizeIpProxyPort(state?.ipProxyPort) : 0)
|
||
);
|
||
const port = Number.isInteger(portValue) && portValue > 0 && portValue <= 65535 ? portValue : 0;
|
||
const region = String(
|
||
state?.ipProxyAppliedRegion
|
||
|| activeEntry?.region
|
||
|| (mode === 'account' ? state?.ipProxyRegion : '')
|
||
|| ''
|
||
).trim();
|
||
const endpoint = host && port > 0 ? `${host}:${port}` : '';
|
||
const endpointWithRegion = endpoint ? `${endpoint}${region ? ` [${region}]` : ''}` : '';
|
||
const hasAuth = Boolean(state?.ipProxyAppliedHasAuth);
|
||
const authSuffix = hasAuth ? '（需要鉴权）' : '';
|
||
const errorText = String(state?.ipProxyAppliedError || '').trim();
|
||
const warningText = String(state?.ipProxyAppliedWarning || '').trim();
|
||
const exitIp = String(state?.ipProxyAppliedExitIp || '').trim();
|
||
const exitRegion = String(state?.ipProxyAppliedExitRegion || '').trim();
|
||
const exitDetecting = Boolean(state?.ipProxyAppliedExitDetecting);
|
||
const exitError = String(state?.ipProxyAppliedExitError || '').trim();
|
||
const exitSource = String(state?.ipProxyAppliedExitSource || '').trim().toLowerCase();
|
||
const exitSourceSuffix = exitSource === 'page_context'
|
||
? '（页面探测）'
|
||
: (exitSource === 'background_fallback'
|
||
? '（后台兜底，可能受全局代理影响）'
|
||
: '');
|
||
const endpointSummary = endpointWithRegion
|
||
? `${endpointWithRegion}${authSuffix}`
|
||
: (endpoint ? `${endpoint}${authSuffix}` : '');
|
||
const exitSummary = exitIp
|
||
? `${exitIp}${exitRegion ? ` [${exitRegion}]` : ''}${exitSourceSuffix}`
|
||
: (exitDetecting ? '检测中...' : '未检测到');
|
||
const details = [accountSourceDetail, errorText, warningText, exitError]
|
||
.map((item) => String(item || '').trim())
|
||
.filter(Boolean)
|
||
.join('\n');
|
||
|
||
if (!enabled) {
|
||
return {
|
||
stateClass: 'state-idle',
|
||
text: '未启用，沿用浏览器默认/全局代理。',
|
||
details: '',
|
||
hideCurrentDisplay: false,
|
||
};
|
||
}
|
||
|
||
if (applied) {
|
||
const statusPrefix = endpointSummary
|
||
? `当前代理：${endpointSummary}${accountSourceTag}`
|
||
: '当前代理：已启用';
|
||
const statusText = `${statusPrefix}；当前出口：${exitSummary}`;
|
||
const briefWarning = warningText
|
||
? '；地区校验未通过（详情可展开查看）'
|
||
: '';
|
||
return {
|
||
stateClass: warningText ? 'state-warning' : 'state-applied',
|
||
text: `${statusText}${briefWarning}`,
|
||
details,
|
||
hideCurrentDisplay: true,
|
||
};
|
||
}
|
||
|
||
if (reason === 'missing_proxy_entry') {
|
||
if (errorText) {
|
||
return {
|
||
stateClass: 'state-warning',
|
||
text: '已启用，但当前没有可用代理（已阻断直连）。',
|
||
details: errorText,
|
||
hideCurrentDisplay: false,
|
||
};
|
||
}
|
||
return {
|
||
stateClass: 'state-warning',
|
||
text: mode === 'account'
|
||
? '已启用，但账号模式没有可用代理。请先填写代理列表，或填写 Host/Port。已阻断所有网站直连。'
|
||
: '已启用，但当前没有可用代理。请先点击“拉取”获取 IP 列表。已阻断所有网站直连。',
|
||
details: '',
|
||
hideCurrentDisplay: false,
|
||
};
|
||
}
|
||
if (reason === 'proxy_api_unavailable') {
|
||
return {
|
||
stateClass: 'state-error',
|
||
text: '已启用，但当前浏览器不支持扩展代理 API，无法应用。',
|
||
details,
|
||
hideCurrentDisplay: false,
|
||
};
|
||
}
|
||
if (reason === 'apply_failed') {
|
||
return {
|
||
stateClass: 'state-error',
|
||
text: '已启用，但代理应用失败（已回退默认代理）。',
|
||
details: errorText || details,
|
||
hideCurrentDisplay: false,
|
||
};
|
||
}
|
||
if (reason === 'connectivity_failed') {
|
||
const prefix = endpointSummary ? `当前代理：${endpointSummary}${accountSourceTag}` : '当前代理：未知';
|
||
const targetUnreachable = /真实目标|chatgpt\.com 不可达|target:page_context/i.test(errorText || details);
|
||
const exitPart = exitIp ? `；当前出口：${exitSummary}` : '';
|
||
return {
|
||
stateClass: 'state-error',
|
||
text: targetUnreachable && exitIp
|
||
? `${prefix}${exitPart}；ChatGPT 目标不可达，请切换支持 ChatGPT 的节点。`
|
||
: `${prefix}${exitPart}；连通性失败，请切换节点或重试。`,
|
||
details: errorText || details,
|
||
hideCurrentDisplay: true,
|
||
};
|
||
}
|
||
|
||
return {
|
||
stateClass: 'state-warning',
|
||
text: endpointWithRegion
|
||
? `已启用，等待生效：${endpointWithRegion}${authSuffix}`
|
||
: '已启用，等待拉取并应用代理。',
|
||
details,
|
||
hideCurrentDisplay: false,
|
||
};
|
||
}
|
||
|
||
function setIpProxyRuntimeStatusDisplay(status = {}) {
|
||
if (!ipProxyRuntimeStatus || !ipProxyRuntimeText) {
|
||
return;
|
||
}
|
||
const text = String(status?.text || '未启用，沿用浏览器默认/全局代理。').trim();
|
||
const stateClass = String(status?.stateClass || 'state-idle').trim() || 'state-idle';
|
||
ipProxyRuntimeStatus.classList.remove('state-idle', 'state-applied', 'state-warning', 'state-error');
|
||
ipProxyRuntimeStatus.classList.add(stateClass);
|
||
ipProxyRuntimeText.textContent = text;
|
||
ipProxyRuntimeText.title = text;
|
||
if (ipProxyRuntimeDot) {
|
||
ipProxyRuntimeDot.title = text;
|
||
}
|
||
const runtimeMeta = ipProxyCurrent?.closest?.('.ip-proxy-runtime-meta') || null;
|
||
if (runtimeMeta) {
|
||
runtimeMeta.style.display = status?.hideCurrentDisplay ? 'none' : '';
|
||
}
|
||
const detailsText = String(status?.details || '').trim();
|
||
if (ipProxyRuntimeDetails && ipProxyRuntimeDetailsText) {
|
||
if (detailsText) {
|
||
ipProxyRuntimeDetails.hidden = false;
|
||
ipProxyRuntimeDetailsText.textContent = detailsText;
|
||
} else {
|
||
ipProxyRuntimeDetails.hidden = true;
|
||
ipProxyRuntimeDetails.open = false;
|
||
ipProxyRuntimeDetailsText.textContent = '';
|
||
}
|
||
}
|
||
}
|
||
|
||
function normalizeIpProxyEnabledInlineRegion(value = '') {
|
||
const normalized = String(value || '').trim();
|
||
return normalized ? normalized.toUpperCase() : '';
|
||
}
|
||
|
||
function setIpProxyEnabledInlineStatus(state = {}, enabled = getSelectedIpProxyEnabled()) {
|
||
if (!ipProxyEnabledStatus || !ipProxyEnabledStatusText) {
|
||
return;
|
||
}
|
||
ipProxyEnabledStatus.classList.remove('is-off', 'is-on');
|
||
|
||
if (!enabled) {
|
||
const text = '未开启';
|
||
ipProxyEnabledStatus.classList.add('is-off');
|
||
ipProxyEnabledStatusText.textContent = text;
|
||
ipProxyEnabledStatusText.title = text;
|
||
ipProxyEnabledStatus.title = text;
|
||
if (ipProxyEnabledStatusDot) {
|
||
ipProxyEnabledStatusDot.title = text;
|
||
}
|
||
return;
|
||
}
|
||
|
||
const region = normalizeIpProxyEnabledInlineRegion(state?.ipProxyAppliedExitRegion)
|
||
|| normalizeIpProxyEnabledInlineRegion(state?.ipProxyAppliedRegion)
|
||
|| normalizeIpProxyEnabledInlineRegion(state?.ipProxyRegion);
|
||
const text = region ? `已开启 · ${region}` : '已开启';
|
||
ipProxyEnabledStatus.classList.add('is-on');
|
||
ipProxyEnabledStatusText.textContent = text;
|
||
ipProxyEnabledStatusText.title = text;
|
||
ipProxyEnabledStatus.title = text;
|
||
if (ipProxyEnabledStatusDot) {
|
||
ipProxyEnabledStatusDot.title = text;
|
||
}
|
||
}
|
||
|
||
function updateIpProxyUI(state = latestState) {
|
||
const enabled = getSelectedIpProxyEnabled();
|
||
const showSettings = enabled && ipProxySectionExpanded;
|
||
const mode = getSelectedIpProxyMode();
|
||
const service = normalizeIpProxyService(selectIpProxyService?.value || state?.ipProxyService || DEFAULT_IP_PROXY_SERVICE);
|
||
const apiModeAvailable = isIpProxyApiModeAvailable();
|
||
const accountListAvailable = isIpProxyAccountListAvailable();
|
||
const isApiMode = mode === 'api' && apiModeAvailable;
|
||
const isAccountMode = mode === 'account';
|
||
const showSessionOptions = isAccountMode && service === '711proxy';
|
||
const hasAccountListConfigured = accountListAvailable && isAccountMode && hasCurrentInputAccountListEntries();
|
||
const canOperate = !isAutoRunLockedPhase() && !isAutoRunScheduledPhase();
|
||
const actionState = getIpProxyActionState();
|
||
const actionBusy = Boolean(actionState.busy);
|
||
const busyAction = normalizeIpProxyActionType(actionState.action);
|
||
const runtimeState = state || latestState || {};
|
||
|
||
if (rowIpProxyEnabled) {
|
||
rowIpProxyEnabled.style.display = '';
|
||
}
|
||
if (btnToggleIpProxySection) {
|
||
btnToggleIpProxySection.disabled = !enabled;
|
||
btnToggleIpProxySection.textContent = showSettings ? '收起设置' : '展开设置';
|
||
btnToggleIpProxySection.title = enabled
|
||
? (showSettings ? '收起 IP 代理设置' : '展开 IP 代理设置')
|
||
: '开启 IP 代理后可展开设置';
|
||
btnToggleIpProxySection.setAttribute('aria-expanded', String(showSettings));
|
||
}
|
||
if (rowIpProxyFold) {
|
||
rowIpProxyFold.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyService) {
|
||
rowIpProxyService.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyMode) {
|
||
rowIpProxyMode.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyLayout) {
|
||
rowIpProxyLayout.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyApiUrl) {
|
||
rowIpProxyApiUrl.style.display = showSettings && apiModeAvailable && isApiMode ? '' : 'none';
|
||
}
|
||
if (rowIpProxyAccountList) {
|
||
rowIpProxyAccountList.style.display = showSettings && isAccountMode && accountListAvailable ? '' : 'none';
|
||
}
|
||
if (rowIpProxyAccountSessionPrefix) {
|
||
rowIpProxyAccountSessionPrefix.style.display = showSettings && showSessionOptions ? '' : 'none';
|
||
}
|
||
if (rowIpProxyAccountLifeMinutes) {
|
||
rowIpProxyAccountLifeMinutes.style.display = showSettings && showSessionOptions ? '' : 'none';
|
||
}
|
||
if (rowIpProxyPoolTargetCount) {
|
||
rowIpProxyPoolTargetCount.style.display = showSettings ? '' : 'none';
|
||
}
|
||
const autoSyncEnabledRow = typeof rowIpProxyAutoSyncEnabled !== 'undefined' ? rowIpProxyAutoSyncEnabled : null;
|
||
const autoSyncIntervalRow = typeof rowIpProxyAutoSyncInterval !== 'undefined' ? rowIpProxyAutoSyncInterval : null;
|
||
if (autoSyncEnabledRow) {
|
||
autoSyncEnabledRow.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (autoSyncIntervalRow) {
|
||
autoSyncIntervalRow.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyHost) {
|
||
rowIpProxyHost.style.display = showSettings && isAccountMode ? '' : 'none';
|
||
}
|
||
if (rowIpProxyPort) {
|
||
rowIpProxyPort.style.display = showSettings && isAccountMode ? '' : 'none';
|
||
}
|
||
if (rowIpProxyProtocol) {
|
||
rowIpProxyProtocol.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyUsername) {
|
||
rowIpProxyUsername.style.display = showSettings && isAccountMode ? '' : 'none';
|
||
}
|
||
if (rowIpProxyPassword) {
|
||
rowIpProxyPassword.style.display = showSettings && isAccountMode ? '' : 'none';
|
||
}
|
||
if (rowIpProxyRegion) {
|
||
rowIpProxyRegion.style.display = showSettings && isAccountMode ? '' : 'none';
|
||
}
|
||
if (rowIpProxyActions) {
|
||
rowIpProxyActions.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (ipProxyActionButtons) {
|
||
ipProxyActionButtons.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (rowIpProxyRuntimeStatus) {
|
||
rowIpProxyRuntimeStatus.style.display = showSettings ? '' : 'none';
|
||
}
|
||
if (ipProxyLayout) {
|
||
ipProxyLayout.classList.toggle('is-account-only', !apiModeAvailable);
|
||
}
|
||
if (selectIpProxyService) {
|
||
selectIpProxyService.value = service;
|
||
selectIpProxyService.disabled = true;
|
||
}
|
||
if (typeof updateIpProxyServiceLoginButtonState === 'function') {
|
||
updateIpProxyServiceLoginButtonState({
|
||
service,
|
||
enabled,
|
||
});
|
||
}
|
||
ipProxyModeButtons.forEach((button) => {
|
||
const buttonMode = normalizeIpProxyMode(button?.dataset?.ipProxyMode || DEFAULT_IP_PROXY_MODE);
|
||
const apiButton = buttonMode === 'api';
|
||
button.disabled = apiButton && !apiModeAvailable;
|
||
if (apiButton) {
|
||
button.hidden = false;
|
||
}
|
||
});
|
||
if (ipProxyApiPanel) {
|
||
ipProxyApiPanel.classList.toggle('is-disabled', !apiModeAvailable);
|
||
ipProxyApiPanel.setAttribute('aria-disabled', String(!apiModeAvailable));
|
||
ipProxyApiPanel.hidden = !apiModeAvailable;
|
||
ipProxyApiPanel.style.display = showSettings && apiModeAvailable ? '' : 'none';
|
||
}
|
||
if (inputIpProxyApiUrl) {
|
||
inputIpProxyApiUrl.disabled = !enabled || !apiModeAvailable;
|
||
}
|
||
if (btnToggleIpProxyApiUrl) {
|
||
btnToggleIpProxyApiUrl.disabled = !enabled || !apiModeAvailable;
|
||
}
|
||
if (inputIpProxyHost) {
|
||
inputIpProxyHost.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (inputIpProxyPort) {
|
||
inputIpProxyPort.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (selectIpProxyProtocol) {
|
||
selectIpProxyProtocol.disabled = !enabled || (isAccountMode && hasAccountListConfigured);
|
||
}
|
||
if (inputIpProxyUsername) {
|
||
inputIpProxyUsername.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (inputIpProxyPassword) {
|
||
inputIpProxyPassword.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (btnToggleIpProxyUsername) {
|
||
btnToggleIpProxyUsername.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (btnToggleIpProxyPassword) {
|
||
btnToggleIpProxyPassword.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (inputIpProxyRegion) {
|
||
inputIpProxyRegion.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (inputIpProxyAccountSessionPrefix) {
|
||
inputIpProxyAccountSessionPrefix.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (inputIpProxyAccountLifeMinutes) {
|
||
inputIpProxyAccountLifeMinutes.disabled = !enabled || !isAccountMode || hasAccountListConfigured;
|
||
}
|
||
if (inputIpProxyAccountList) {
|
||
inputIpProxyAccountList.disabled = !enabled || !isAccountMode || !accountListAvailable;
|
||
}
|
||
const autoSyncEnabledInput = typeof inputIpProxyAutoSyncEnabled !== 'undefined' ? inputIpProxyAutoSyncEnabled : null;
|
||
const autoSyncIntervalInput = typeof inputIpProxyAutoSyncIntervalMinutes !== 'undefined' ? inputIpProxyAutoSyncIntervalMinutes : null;
|
||
if (autoSyncEnabledInput) {
|
||
autoSyncEnabledInput.disabled = !enabled;
|
||
}
|
||
if (autoSyncIntervalInput) {
|
||
const autoSyncEnabled = Boolean(autoSyncEnabledInput?.checked);
|
||
if (!Number.isFinite(Number.parseInt(String(autoSyncIntervalInput.value || '').trim(), 10))) {
|
||
autoSyncIntervalInput.value = '15';
|
||
}
|
||
autoSyncIntervalInput.disabled = !enabled || !autoSyncEnabled;
|
||
}
|
||
|
||
const runtimeStatus = formatIpProxyRuntimeStatus(runtimeState);
|
||
setIpProxyRuntimeStatusDisplay(runtimeStatus);
|
||
const currentDisplay = formatIpProxyCurrentDisplay(runtimeState);
|
||
const currentDisplayText = buildIpProxyCurrentDisplayText(currentDisplay, runtimeStatus);
|
||
setIpProxyCurrentDisplay(currentDisplayText, currentDisplay.hasValue);
|
||
const runtimeSnapshot = getIpProxyRuntimeSnapshot(runtimeState, mode, service);
|
||
const runtimePoolCount = Array.isArray(runtimeSnapshot?.pool) ? runtimeSnapshot.pool.length : 0;
|
||
const runtimePoolCountForDisplay = runtimePoolCount > 0 ? runtimePoolCount : 1;
|
||
const hasCurrentEntry = Boolean(getIpProxyCurrentEntry(runtimeState));
|
||
const changeAvailable = canChangeIpProxyExitWithCurrentSession(runtimeState);
|
||
const nextActionTitle = runtimePoolCount > 1
|
||
? `切换到代理池下一条节点并应用（当前共 ${runtimePoolCountForDisplay} 条）`
|
||
: `当前仅 ${runtimePoolCountForDisplay} 条节点：重绑当前节点并复测连通性（不保证更换出口）`;
|
||
|
||
if (btnIpProxyRefresh) {
|
||
btnIpProxyRefresh.disabled = actionBusy || !enabled || !canOperate;
|
||
btnIpProxyRefresh.textContent = busyAction === 'refresh'
|
||
? (isApiMode ? '拉取中...' : '同步中...')
|
||
: (isApiMode ? '拉取' : '同步');
|
||
btnIpProxyRefresh.title = isApiMode ? '拉取代理池并应用当前代理' : '同步账号代理列表并应用当前代理';
|
||
}
|
||
if (btnIpProxyNext) {
|
||
btnIpProxyNext.disabled = actionBusy || !enabled || !canOperate || !hasCurrentEntry;
|
||
btnIpProxyNext.textContent = busyAction === 'next' ? '切换中...' : '下一条';
|
||
btnIpProxyNext.title = nextActionTitle;
|
||
}
|
||
if (btnIpProxyChange) {
|
||
btnIpProxyChange.disabled = actionBusy || !enabled || !canOperate || !changeAvailable;
|
||
btnIpProxyChange.textContent = busyAction === 'change' ? 'Change中...' : 'Change';
|
||
btnIpProxyChange.title = changeAvailable
|
||
? '保持当前会话并刷新出口（仅 711 + session）'
|
||
: '当前模式不支持 Change（需 711 账号模式且用户名包含 session）';
|
||
}
|
||
if (btnIpProxyProbe) {
|
||
btnIpProxyProbe.disabled = actionBusy || !enabled || !canOperate;
|
||
btnIpProxyProbe.textContent = busyAction === 'probe' ? '检测中...' : '检测出口';
|
||
}
|
||
if (btnIpProxyCheckIp) {
|
||
btnIpProxyCheckIp.disabled = false;
|
||
btnIpProxyCheckIp.title = '打开公网 IP 检测页';
|
||
}
|
||
if (ipProxyActionHint) {
|
||
const actionHint = buildIpProxyActionHintText({
|
||
mode,
|
||
poolCount: runtimePoolCount,
|
||
changeAvailable,
|
||
});
|
||
ipProxyActionHint.textContent = actionHint;
|
||
ipProxyActionHint.title = actionHint;
|
||
}
|
||
}
|
||
|
||
async function refreshIpProxyPoolByApi(options = {}) {
|
||
const { silent = false } = options;
|
||
const mode = normalizeIpProxyModeForCurrentRelease(getSelectedIpProxyMode());
|
||
const response = await chrome.runtime.sendMessage({
|
||
type: 'REFRESH_IP_PROXY_POOL',
|
||
source: 'sidepanel',
|
||
payload: {
|
||
mode,
|
||
skipExitProbe: true,
|
||
},
|
||
});
|
||
if (response?.error) {
|
||
throw new Error(response.error);
|
||
}
|
||
|
||
const responseMode = normalizeIpProxyModeForCurrentRelease(response?.mode || mode);
|
||
const patch = {};
|
||
Object.assign(patch, buildIpProxyRuntimeStatePatchForMode(responseMode, response));
|
||
if (response?.proxyRouting && typeof response.proxyRouting === 'object') {
|
||
patch.ipProxyApplied = Boolean(response.proxyRouting.applied);
|
||
patch.ipProxyAppliedReason = String(response.proxyRouting.reason || '').trim().toLowerCase();
|
||
patch.ipProxyAppliedHost = String(response.proxyRouting.host || '').trim();
|
||
patch.ipProxyAppliedPort = Number(response.proxyRouting.port) || 0;
|
||
patch.ipProxyAppliedRegion = String(response.proxyRouting.region || '').trim();
|
||
patch.ipProxyAppliedHasAuth = Boolean(response.proxyRouting.hasAuth);
|
||
patch.ipProxyAppliedProvider = normalizeIpProxyService(response.proxyRouting.provider || '');
|
||
patch.ipProxyAppliedError = String(response.proxyRouting.error || '').trim();
|
||
patch.ipProxyAppliedWarning = String(response.proxyRouting.warning || '').trim();
|
||
patch.ipProxyAppliedExitIp = String(response.proxyRouting.exitIp || '').trim();
|
||
patch.ipProxyAppliedExitRegion = String(response.proxyRouting.exitRegion || '').trim();
|
||
patch.ipProxyAppliedExitDetecting = Boolean(response.proxyRouting.exitDetecting);
|
||
patch.ipProxyAppliedExitError = String(response.proxyRouting.exitError || '').trim();
|
||
patch.ipProxyAppliedExitSource = String(response.proxyRouting.exitSource || '').trim().toLowerCase();
|
||
patch.ipProxyAppliedAt = Date.now();
|
||
}
|
||
if (Object.keys(patch).length) {
|
||
syncLatestState(patch);
|
||
}
|
||
updateIpProxyUI(latestState);
|
||
scheduleIpProxyExitProbe({ silent: true });
|
||
|
||
if (!silent) {
|
||
if (mode === 'account') {
|
||
showToast(`已同步账号代理：${response?.display || formatIpProxyCurrentDisplay(latestState).text}`, 'success', 1800);
|
||
} else {
|
||
showToast(`已拉取代理池：${Number(response?.count) || 0} 条`, 'success', 1800);
|
||
}
|
||
}
|
||
return response;
|
||
}
|
||
|
||
async function switchIpProxyToNext(options = {}) {
|
||
const { silent = false } = options;
|
||
const mode = normalizeIpProxyModeForCurrentRelease(getSelectedIpProxyMode());
|
||
const response = await chrome.runtime.sendMessage({
|
||
type: 'SWITCH_IP_PROXY',
|
||
source: 'sidepanel',
|
||
payload: {
|
||
direction: 'next',
|
||
mode,
|
||
forceRefresh: false,
|
||
skipExitProbe: true,
|
||
},
|
||
});
|
||
if (response?.error) {
|
||
throw new Error(response.error);
|
||
}
|
||
const responseMode = normalizeIpProxyModeForCurrentRelease(response?.mode || mode);
|
||
const patch = {};
|
||
Object.assign(patch, buildIpProxyRuntimeStatePatchForMode(responseMode, response));
|
||
if (response?.proxyRouting && typeof response.proxyRouting === 'object') {
|
||
patch.ipProxyApplied = Boolean(response.proxyRouting.applied);
|
||
patch.ipProxyAppliedReason = String(response.proxyRouting.reason || '').trim().toLowerCase();
|
||
patch.ipProxyAppliedHost = String(response.proxyRouting.host || '').trim();
|
||
patch.ipProxyAppliedPort = Number(response.proxyRouting.port) || 0;
|
||
patch.ipProxyAppliedRegion = String(response.proxyRouting.region || '').trim();
|
||
patch.ipProxyAppliedHasAuth = Boolean(response.proxyRouting.hasAuth);
|
||
patch.ipProxyAppliedProvider = normalizeIpProxyService(response.proxyRouting.provider || '');
|
||
patch.ipProxyAppliedError = String(response.proxyRouting.error || '').trim();
|
||
patch.ipProxyAppliedWarning = String(response.proxyRouting.warning || '').trim();
|
||
patch.ipProxyAppliedExitIp = String(response.proxyRouting.exitIp || '').trim();
|
||
patch.ipProxyAppliedExitRegion = String(response.proxyRouting.exitRegion || '').trim();
|
||
patch.ipProxyAppliedExitDetecting = Boolean(response.proxyRouting.exitDetecting);
|
||
patch.ipProxyAppliedExitError = String(response.proxyRouting.exitError || '').trim();
|
||
patch.ipProxyAppliedExitSource = String(response.proxyRouting.exitSource || '').trim().toLowerCase();
|
||
patch.ipProxyAppliedAt = Date.now();
|
||
}
|
||
if (Object.keys(patch).length) {
|
||
syncLatestState(patch);
|
||
}
|
||
updateIpProxyUI(latestState);
|
||
scheduleIpProxyExitProbe({ silent: true });
|
||
if (!silent) {
|
||
showToast(`已切换代理：${response?.display || formatIpProxyCurrentDisplay(latestState).text}`, 'success', 1800);
|
||
}
|
||
return response;
|
||
}
|
||
|
||
async function changeIpProxyExitBySession(options = {}) {
|
||
const { silent = false } = options;
|
||
const mode = normalizeIpProxyModeForCurrentRelease(getSelectedIpProxyMode());
|
||
const response = await chrome.runtime.sendMessage({
|
||
type: 'CHANGE_IP_PROXY_EXIT',
|
||
source: 'sidepanel',
|
||
payload: {
|
||
mode,
|
||
skipExitProbe: true,
|
||
},
|
||
});
|
||
if (response?.error) {
|
||
throw new Error(response.error);
|
||
}
|
||
const responseMode = normalizeIpProxyModeForCurrentRelease(response?.mode || mode);
|
||
const patch = {};
|
||
Object.assign(patch, buildIpProxyRuntimeStatePatchForMode(responseMode, response));
|
||
if (response?.proxyRouting && typeof response.proxyRouting === 'object') {
|
||
patch.ipProxyApplied = Boolean(response.proxyRouting.applied);
|
||
patch.ipProxyAppliedReason = String(response.proxyRouting.reason || '').trim().toLowerCase();
|
||
patch.ipProxyAppliedHost = String(response.proxyRouting.host || '').trim();
|
||
patch.ipProxyAppliedPort = Number(response.proxyRouting.port) || 0;
|
||
patch.ipProxyAppliedRegion = String(response.proxyRouting.region || '').trim();
|
||
patch.ipProxyAppliedHasAuth = Boolean(response.proxyRouting.hasAuth);
|
||
patch.ipProxyAppliedProvider = normalizeIpProxyService(response.proxyRouting.provider || '');
|
||
patch.ipProxyAppliedError = String(response.proxyRouting.error || '').trim();
|
||
patch.ipProxyAppliedWarning = String(response.proxyRouting.warning || '').trim();
|
||
patch.ipProxyAppliedExitIp = String(response.proxyRouting.exitIp || '').trim();
|
||
patch.ipProxyAppliedExitRegion = String(response.proxyRouting.exitRegion || '').trim();
|
||
patch.ipProxyAppliedExitDetecting = Boolean(response.proxyRouting.exitDetecting);
|
||
patch.ipProxyAppliedExitError = String(response.proxyRouting.exitError || '').trim();
|
||
patch.ipProxyAppliedExitSource = String(response.proxyRouting.exitSource || '').trim().toLowerCase();
|
||
patch.ipProxyAppliedAt = Date.now();
|
||
}
|
||
if (Object.keys(patch).length) {
|
||
syncLatestState(patch);
|
||
}
|
||
updateIpProxyUI(latestState);
|
||
scheduleIpProxyExitProbe({ silent: true });
|
||
if (!silent) {
|
||
showToast(`已执行 Change：${response?.display || formatIpProxyCurrentDisplay(latestState).text}`, 'success', 1800);
|
||
}
|
||
return response;
|
||
}
|
||
|
||
async function probeIpProxyExit(options = {}) {
|
||
const { silent = false } = options;
|
||
const sendMessage = typeof sendSidepanelMessage === 'function'
|
||
? sendSidepanelMessage
|
||
: (message) => chrome.runtime.sendMessage(message);
|
||
const response = await sendMessage({
|
||
type: 'PROBE_IP_PROXY_EXIT',
|
||
source: 'sidepanel',
|
||
payload: {},
|
||
});
|
||
if (response?.error) {
|
||
throw new Error(response.error);
|
||
}
|
||
const routing = response?.proxyRouting || {};
|
||
syncLatestState({
|
||
ipProxyApplied: Boolean(routing.applied),
|
||
ipProxyAppliedReason: String(routing.reason || '').trim().toLowerCase(),
|
||
ipProxyAppliedHost: String(routing.host || '').trim(),
|
||
ipProxyAppliedPort: Number(routing.port) || 0,
|
||
ipProxyAppliedRegion: String(routing.region || '').trim(),
|
||
ipProxyAppliedHasAuth: Boolean(routing.hasAuth),
|
||
ipProxyAppliedProvider: normalizeIpProxyService(routing.provider || ''),
|
||
ipProxyAppliedError: String(routing.error || '').trim(),
|
||
ipProxyAppliedWarning: String(routing.warning || '').trim(),
|
||
ipProxyAppliedExitIp: String(routing.exitIp || '').trim(),
|
||
ipProxyAppliedExitRegion: String(routing.exitRegion || '').trim(),
|
||
ipProxyAppliedExitDetecting: Boolean(routing.exitDetecting),
|
||
ipProxyAppliedExitError: String(routing.exitError || '').trim(),
|
||
ipProxyAppliedExitSource: String(routing.exitSource || '').trim().toLowerCase(),
|
||
ipProxyAppliedAt: Date.now(),
|
||
});
|
||
updateIpProxyUI(latestState);
|
||
|
||
if (!silent) {
|
||
const exitIp = String(routing?.exitIp || '').trim();
|
||
const exitRegion = String(routing?.exitRegion || '').trim();
|
||
const exitSource = String(routing?.exitSource || '').trim().toLowerCase();
|
||
const sourceHint = exitSource === 'background_fallback'
|
||
? '（后台兜底，可能受全局代理影响）'
|
||
: '';
|
||
if (exitIp) {
|
||
showToast(`出口检测成功：${exitIp}${exitRegion ? ` [${exitRegion}]` : ''}${sourceHint}`, 'success', 2600);
|
||
} else {
|
||
showToast('出口检测完成，但未获取到出口 IP', 'warn', 2200);
|
||
}
|
||
}
|
||
return response;
|
||
}
|