@astralyn/sash 0.1.0

package/dist/sysproxy/factory.js

@@ -0,0 +1,71 @@
+import { isSystemProxySupported } from "./common.js";
+import { applyDarwinSnapshot, captureDarwinSnapshot, createDarwinTarget, darwinState, } from "./darwin.js";
+import { applyLinuxSnapshot, captureLinuxSnapshot, createLinuxTarget, linuxState, } from "./gnome.js";
+import { parseSystemProxySnapshot, snapshotsCompatible, snapshotsEquivalent } from "./snapshot.js";
+import { applyWindowsSnapshot, captureWindowsSnapshot, createWindowsTarget, windowsState, } from "./windows.js";
+function createSupportedBackend(operations) {
+    return {
+        supported: true,
+        capture: () => operations.capture(),
+        createTarget: (original, opts) => operations.createTarget(original, opts),
+        apply: (snapshot) => operations.apply(snapshot),
+        equivalent: snapshotsEquivalent,
+        compatible: snapshotsCompatible,
+        state: (snapshot) => operations.state(snapshot),
+    };
+}
+class UnsupportedSystemProxyBackend {
+    details;
+    supported = false;
+    constructor(details) {
+        this.details = details;
+    }
+    async capture() {
+        throw new Error(this.details);
+    }
+    createTarget(_original, _opts) {
+        throw new Error(this.details);
+    }
+    async apply(_snapshot) {
+        throw new Error(this.details);
+    }
+    equivalent(a, b) {
+        return snapshotsEquivalent(a, b);
+    }
+    compatible(_current, _original, _target) {
+        return false;
+    }
+    state(snapshot) {
+        parseSystemProxySnapshot(snapshot);
+        return { supported: false, enabled: false, details: this.details };
+    }
+}
+export function createSystemProxyBackend(platform = process.platform) {
+    switch (platform) {
+        case "win32":
+            return createSupportedBackend({
+                capture: captureWindowsSnapshot,
+                createTarget: createWindowsTarget,
+                apply: applyWindowsSnapshot,
+                state: windowsState,
+            });
+        case "darwin":
+            return createSupportedBackend({
+                capture: captureDarwinSnapshot,
+                createTarget: createDarwinTarget,
+                apply: applyDarwinSnapshot,
+                state: darwinState,
+            });
+        case "linux":
+            return isSystemProxySupported("linux")
+                ? createSupportedBackend({
+                    capture: captureLinuxSnapshot,
+                    createTarget: createLinuxTarget,
+                    apply: applyLinuxSnapshot,
+                    state: linuxState,
+                })
+                : new UnsupportedSystemProxyBackend("gsettings not available; desktop proxy configuration unsupported");
+        default:
+            return new UnsupportedSystemProxyBackend(`unsupported platform: ${platform}`);
+    }
+}

package/dist/sysproxy/gnome.js

@@ -0,0 +1,181 @@
+import { formatHostPort, isSystemProxySupported, normalizeEnableOptions, parseProxyString, runCmd, } from "./common.js";
+import { linuxSnapshot } from "./snapshot.js";
+import { SYSTEM_PROXY_SNAPSHOT_VERSION } from "./types.js";
+function ensureGSettingsAvailable() {
+    if (!isSystemProxySupported("linux")) {
+        throw new Error("System proxy cannot be configured automatically: gsettings is not available on this system.");
+    }
+}
+function decodeGSettingsString(content) {
+    let decoded = "";
+    for (let index = 0; index < content.length; index++) {
+        const char = content[index];
+        if (char !== "\\") {
+            decoded += char;
+            continue;
+        }
+        const escaped = content[index + 1];
+        if (escaped === undefined)
+            throw new Error("Invalid gsettings string: trailing escape");
+        index++;
+        switch (escaped) {
+            case "\\":
+                decoded += "\\";
+                break;
+            case "'":
+                decoded += "'";
+                break;
+            case "n":
+                decoded += "\n";
+                break;
+            case "r":
+                decoded += "\r";
+                break;
+            case "t":
+                decoded += "\t";
+                break;
+            case "b":
+                decoded += "\b";
+                break;
+            case "f":
+                decoded += "\f";
+                break;
+            default:
+                throw new Error(`Invalid gsettings string: unsupported escape \\${escaped}`);
+        }
+    }
+    return decoded;
+}
+export function parseGSettingsString(output) {
+    const value = output.trim();
+    if (value.length < 2 || !value.startsWith("'") || !value.endsWith("'")) {
+        throw new Error("Invalid gsettings string: expected a single-quoted value");
+    }
+    return decodeGSettingsString(value.slice(1, -1));
+}
+function formatGSettingsString(value) {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+export function parseGSettingsPort(output, label) {
+    const value = output.trim();
+    const match = value.match(/^(?:uint16\s+)?(\d+)$/);
+    if (!match?.[1]) {
+        throw new Error(`Invalid gsettings ${label}: expected an integer`);
+    }
+    const port = Number.parseInt(match[1], 10);
+    if (port < 0 || port > 65_535) {
+        throw new Error(`Invalid gsettings ${label}: expected an integer from 0 to 65535`);
+    }
+    return port;
+}
+function parseGSettingsBoolean(output, label) {
+    const value = output.trim();
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    throw new Error(`Invalid gsettings ${label}: expected true or false`);
+}
+async function getLinuxEndpoint(protocol, run) {
+    const schema = `org.gnome.system.proxy.${protocol}`;
+    return {
+        host: parseProxyString(await runGSettingsGet(schema, "host", run), `${protocol} host`),
+        port: parseGSettingsPort(await run("gsettings", ["get", schema, "port"]), `${protocol} port`),
+    };
+}
+async function runGSettingsGet(schema, key, run) {
+    return parseGSettingsString(await run("gsettings", ["get", schema, key]));
+}
+export async function captureLinuxSnapshot(run = runCmd, ensureAvailable = ensureGSettingsAvailable) {
+    ensureAvailable();
+    const mode = await runGSettingsGet("org.gnome.system.proxy", "mode", run);
+    if (mode !== "none" && mode !== "manual" && mode !== "auto") {
+        throw new Error("Invalid gsettings mode: expected none, manual, or auto");
+    }
+    const autoConfigUrl = await runGSettingsGet("org.gnome.system.proxy", "autoconfig-url", run);
+    const httpUseAuthentication = parseGSettingsBoolean(await run("gsettings", ["get", "org.gnome.system.proxy.http", "use-authentication"]), "HTTP authentication state");
+    const http = await getLinuxEndpoint("http", run);
+    const https = await getLinuxEndpoint("https", run);
+    const socks = await getLinuxEndpoint("socks", run);
+    return {
+        version: SYSTEM_PROXY_SNAPSHOT_VERSION,
+        platform: "linux",
+        mode,
+        autoConfigUrl,
+        httpUseAuthentication,
+        http,
+        https,
+        socks,
+    };
+}
+export async function applyLinuxSnapshot(value, run = runCmd, ensureAvailable = ensureGSettingsAvailable) {
+    const snapshot = linuxSnapshot(value);
+    ensureAvailable();
+    const endpoints = [
+        { schema: "org.gnome.system.proxy.http", value: snapshot.http },
+        { schema: "org.gnome.system.proxy.https", value: snapshot.https },
+        { schema: "org.gnome.system.proxy.socks", value: snapshot.socks },
+    ];
+    await run("gsettings", [
+        "set",
+        "org.gnome.system.proxy",
+        "autoconfig-url",
+        formatGSettingsString(snapshot.autoConfigUrl),
+    ]);
+    await run("gsettings", [
+        "set",
+        "org.gnome.system.proxy.http",
+        "use-authentication",
+        snapshot.httpUseAuthentication ? "true" : "false",
+    ]);
+    for (const endpoint of endpoints) {
+        await run("gsettings", [
+            "set",
+            endpoint.schema,
+            "host",
+            formatGSettingsString(endpoint.value.host),
+        ]);
+        await run("gsettings", ["set", endpoint.schema, "port", String(endpoint.value.port)]);
+    }
+    await run("gsettings", [
+        "set",
+        "org.gnome.system.proxy",
+        "mode",
+        formatGSettingsString(snapshot.mode),
+    ]);
+}
+export function createLinuxTarget(original, opts) {
+    const snapshot = linuxSnapshot(original);
+    const normalized = normalizeEnableOptions(opts);
+    const endpoint = () => ({ host: normalized.host, port: normalized.port });
+    return {
+        version: SYSTEM_PROXY_SNAPSHOT_VERSION,
+        platform: "linux",
+        mode: "manual",
+        autoConfigUrl: snapshot.autoConfigUrl,
+        httpUseAuthentication: false,
+        http: endpoint(),
+        https: endpoint(),
+        socks: endpoint(),
+    };
+}
+export function linuxState(value) {
+    const snapshot = linuxSnapshot(value);
+    if (snapshot.mode === "auto") {
+        return {
+            supported: true,
+            enabled: true,
+            ...(snapshot.autoConfigUrl ? { server: snapshot.autoConfigUrl } : {}),
+            details: "automatic proxy configuration is enabled",
+        };
+    }
+    const enabled = snapshot.mode === "manual";
+    if (!enabled || !snapshot.http.host || snapshot.http.port === 0) {
+        return { supported: true, enabled };
+    }
+    return {
+        supported: true,
+        enabled,
+        server: formatHostPort(snapshot.http.host, snapshot.http.port),
+    };
+}

package/dist/sysproxy/legacy.js

@@ -0,0 +1,58 @@
+import { formatHostPort, normalizeEnableOptions } from "./common.js";
+import { createSystemProxyBackend } from "./factory.js";
+import { parseSystemProxySnapshot } from "./snapshot.js";
+export function createLegacyProxyCleanup(value, opts) {
+    const snapshot = parseSystemProxySnapshot(value);
+    const normalized = normalizeEnableOptions(opts);
+    const target = formatHostPort(normalized.host, normalized.port);
+    switch (snapshot.platform) {
+        case "win32":
+            return snapshot.proxyEnable === 1 && snapshot.proxyServer === target
+                ? { ...snapshot, proxyEnable: 0 }
+                : undefined;
+        case "darwin": {
+            let matched = false;
+            let conflict = false;
+            const clean = (setting) => {
+                if (!setting.enabled)
+                    return setting;
+                if (formatHostPort(setting.server, setting.port) !== target) {
+                    conflict = true;
+                    return setting;
+                }
+                matched = true;
+                return { ...setting, enabled: false };
+            };
+            const services = snapshot.services.map((service) => ({
+                ...service,
+                web: clean(service.web),
+                secureWeb: clean(service.secureWeb),
+                socks: clean(service.socks),
+            }));
+            if (!matched || conflict)
+                return undefined;
+            return { ...snapshot, services };
+        }
+        case "linux":
+            if (snapshot.mode !== "manual" ||
+                [snapshot.http, snapshot.https, snapshot.socks].some((endpoint) => formatHostPort(endpoint.host, endpoint.port) !== target)) {
+                return undefined;
+            }
+            return { ...snapshot, mode: "none" };
+    }
+}
+export async function disableLegacySystemProxyIfOwned(opts) {
+    const backend = createSystemProxyBackend();
+    if (backend.supported === false)
+        return false;
+    const current = await backend.capture();
+    const cleanup = createLegacyProxyCleanup(current, opts);
+    if (!cleanup)
+        return false;
+    await backend.apply(cleanup);
+    const verified = await backend.capture();
+    if (!backend.equivalent(verified, cleanup)) {
+        throw new Error("Legacy system proxy cleanup could not be verified");
+    }
+    return true;
+}

package/dist/sysproxy/snapshot.js

@@ -0,0 +1,284 @@
+import { hasExactOwnKeys } from "../json-shape.js";
+import { compareStrings, isPlainObject, parseProxyEnable, parseProxyString, parseServiceName, parseSnapshotPort, } from "./common.js";
+import { SYSTEM_PROXY_SNAPSHOT_VERSION } from "./types.js";
+const MAX_NETWORK_SERVICES = 256;
+function hasExactKeys(value, keys, label) {
+    if (!isPlainObject(value)) {
+        throw new Error(`Invalid system proxy snapshot: ${label} must be a plain object`);
+    }
+    if (!hasExactOwnKeys(value, keys)) {
+        throw new Error(`Invalid system proxy snapshot: ${label} has unexpected fields`);
+    }
+    return value;
+}
+function parseDarwinSnapshotSetting(value, label) {
+    const record = hasExactKeys(value, ["enabled", "server", "port", "authenticated"], label);
+    if (typeof record.enabled !== "boolean") {
+        throw new Error(`Invalid system proxy snapshot: ${label}.enabled must be a boolean`);
+    }
+    if (typeof record.authenticated !== "boolean") {
+        throw new Error(`Invalid system proxy snapshot: ${label}.authenticated must be a boolean`);
+    }
+    return {
+        enabled: record.enabled,
+        server: parseProxyString(record.server, `${label}.server`),
+        port: parseSnapshotPort(record.port, `${label}.port`),
+        authenticated: record.authenticated,
+    };
+}
+function parseDarwinAutoSetting(value, label) {
+    const record = hasExactKeys(value, ["enabled", "url"], label);
+    if (typeof record.enabled !== "boolean") {
+        throw new Error(`Invalid system proxy snapshot: ${label}.enabled must be a boolean`);
+    }
+    return {
+        enabled: record.enabled,
+        url: parseProxyString(record.url, `${label}.url`),
+    };
+}
+function parseLinuxEndpoint(value, label) {
+    const record = hasExactKeys(value, ["host", "port"], label);
+    return {
+        host: parseProxyString(record.host, `${label}.host`),
+        port: parseSnapshotPort(record.port, `${label}.port`),
+    };
+}
+function parseWindowsSnapshot(value) {
+    const record = hasExactKeys(value, [
+        "version",
+        "platform",
+        "proxyEnable",
+        "proxyServer",
+        "proxyOverride",
+        "autoConfigUrl",
+        "autoDetect",
+    ], "Windows snapshot");
+    if (record.version !== SYSTEM_PROXY_SNAPSHOT_VERSION || record.platform !== "win32") {
+        throw new Error("Invalid system proxy snapshot: expected version 1 Windows snapshot");
+    }
+    if (record.proxyServer !== null && typeof record.proxyServer !== "string") {
+        throw new Error("Invalid system proxy snapshot: proxyServer must be a string or null");
+    }
+    if (record.proxyOverride !== null && typeof record.proxyOverride !== "string") {
+        throw new Error("Invalid system proxy snapshot: proxyOverride must be a string or null");
+    }
+    if (record.autoConfigUrl !== null && typeof record.autoConfigUrl !== "string") {
+        throw new Error("Invalid system proxy snapshot: autoConfigUrl must be a string or null");
+    }
+    return {
+        version: SYSTEM_PROXY_SNAPSHOT_VERSION,
+        platform: "win32",
+        proxyEnable: parseProxyEnable(record.proxyEnable),
+        proxyServer: record.proxyServer === null ? null : parseProxyString(record.proxyServer, "proxyServer"),
+        proxyOverride: record.proxyOverride === null
+            ? null
+            : parseProxyString(record.proxyOverride, "proxyOverride"),
+        autoConfigUrl: record.autoConfigUrl === null
+            ? null
+            : parseProxyString(record.autoConfigUrl, "autoConfigUrl"),
+        autoDetect: parseProxyEnable(record.autoDetect),
+    };
+}
+function parseDarwinSnapshot(value) {
+    const record = hasExactKeys(value, ["version", "platform", "services"], "macOS snapshot");
+    if (record.version !== SYSTEM_PROXY_SNAPSHOT_VERSION || record.platform !== "darwin") {
+        throw new Error("Invalid system proxy snapshot: expected version 1 macOS snapshot");
+    }
+    if (!Array.isArray(record.services)) {
+        throw new Error("Invalid system proxy snapshot: services must be an array");
+    }
+    if (record.services.length > MAX_NETWORK_SERVICES) {
+        throw new Error("Invalid system proxy snapshot: services has too many entries");
+    }
+    const services = record.services.map((value, index) => {
+        const service = hasExactKeys(value, ["service", "web", "secureWeb", "socks", "auto"], `services[${index}]`);
+        return {
+            service: parseServiceName(service.service, `services[${index}].service`),
+            web: parseDarwinSnapshotSetting(service.web, `services[${index}].web`),
+            secureWeb: parseDarwinSnapshotSetting(service.secureWeb, `services[${index}].secureWeb`),
+            socks: parseDarwinSnapshotSetting(service.socks, `services[${index}].socks`),
+            auto: parseDarwinAutoSetting(service.auto, `services[${index}].auto`),
+        };
+    });
+    services.sort((a, b) => compareStrings(a.service, b.service));
+    for (let index = 1; index < services.length; index++) {
+        if (services[index - 1]?.service === services[index]?.service) {
+            throw new Error("Invalid system proxy snapshot: services must not contain duplicate names");
+        }
+    }
+    return {
+        version: SYSTEM_PROXY_SNAPSHOT_VERSION,
+        platform: "darwin",
+        services,
+    };
+}
+function parseLinuxSnapshot(value) {
+    const record = hasExactKeys(value, [
+        "version",
+        "platform",
+        "mode",
+        "autoConfigUrl",
+        "httpUseAuthentication",
+        "http",
+        "https",
+        "socks",
+    ], "Linux snapshot");
+    if (record.version !== SYSTEM_PROXY_SNAPSHOT_VERSION || record.platform !== "linux") {
+        throw new Error("Invalid system proxy snapshot: expected version 1 Linux snapshot");
+    }
+    if (record.mode !== "none" && record.mode !== "manual" && record.mode !== "auto") {
+        throw new Error("Invalid system proxy snapshot: mode must be none, manual, or auto");
+    }
+    if (typeof record.httpUseAuthentication !== "boolean") {
+        throw new Error("Invalid system proxy snapshot: httpUseAuthentication must be a boolean");
+    }
+    return {
+        version: SYSTEM_PROXY_SNAPSHOT_VERSION,
+        platform: "linux",
+        mode: record.mode,
+        autoConfigUrl: parseProxyString(record.autoConfigUrl, "autoConfigUrl"),
+        httpUseAuthentication: record.httpUseAuthentication,
+        http: parseLinuxEndpoint(record.http, "http"),
+        https: parseLinuxEndpoint(record.https, "https"),
+        socks: parseLinuxEndpoint(record.socks, "socks"),
+    };
+}
+export function parseSystemProxySnapshot(value) {
+    if (!isPlainObject(value)) {
+        throw new Error("Invalid system proxy snapshot: root must be a plain object");
+    }
+    switch (value.platform) {
+        case "win32":
+            return parseWindowsSnapshot(value);
+        case "darwin":
+            return parseDarwinSnapshot(value);
+        case "linux":
+            return parseLinuxSnapshot(value);
+        default:
+            throw new Error("Invalid system proxy snapshot: platform must be win32, darwin, or linux");
+    }
+}
+export function isSystemProxySnapshot(value) {
+    try {
+        parseSystemProxySnapshot(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function windowsSnapshot(value) {
+    const snapshot = parseSystemProxySnapshot(value);
+    if (snapshot.platform !== "win32") {
+        throw new Error("Invalid system proxy snapshot: expected Windows snapshot");
+    }
+    return snapshot;
+}
+export function darwinSnapshot(value) {
+    const snapshot = parseSystemProxySnapshot(value);
+    if (snapshot.platform !== "darwin") {
+        throw new Error("Invalid system proxy snapshot: expected macOS snapshot");
+    }
+    return snapshot;
+}
+export function linuxSnapshot(value) {
+    const snapshot = parseSystemProxySnapshot(value);
+    if (snapshot.platform !== "linux") {
+        throw new Error("Invalid system proxy snapshot: expected Linux snapshot");
+    }
+    return snapshot;
+}
+function normalizeForEquivalence(snapshot) {
+    return snapshot.platform === "win32" ? { ...snapshot, autoDetect: null } : snapshot;
+}
+export function snapshotsEquivalent(a, b) {
+    try {
+        return (JSON.stringify(normalizeForEquivalence(parseSystemProxySnapshot(a))) ===
+            JSON.stringify(normalizeForEquivalence(parseSystemProxySnapshot(b))));
+    }
+    catch {
+        return false;
+    }
+}
+function leafIsCompatible(current, original, target) {
+    return current === original || current === target;
+}
+function sameDarwinServices(a, b) {
+    if (a.services.length !== b.services.length)
+        return false;
+    for (let index = 0; index < a.services.length; index++) {
+        if (a.services[index]?.service !== b.services[index]?.service)
+            return false;
+    }
+    return true;
+}
+function darwinSettingIsCompatible(current, original, target) {
+    return (leafIsCompatible(current.enabled, original.enabled, target.enabled) &&
+        leafIsCompatible(current.server, original.server, target.server) &&
+        leafIsCompatible(current.port, original.port, target.port) &&
+        leafIsCompatible(current.authenticated, original.authenticated, target.authenticated));
+}
+function darwinAutoSettingIsCompatible(current, original, target) {
+    return (leafIsCompatible(current.enabled, original.enabled, target.enabled) &&
+        leafIsCompatible(current.url, original.url, target.url));
+}
+function linuxEndpointIsCompatible(current, original, target) {
+    return (leafIsCompatible(current.host, original.host, target.host) &&
+        leafIsCompatible(current.port, original.port, target.port));
+}
+export function snapshotsCompatible(current, original, target) {
+    try {
+        const parsedCurrent = parseSystemProxySnapshot(current);
+        const parsedOriginal = parseSystemProxySnapshot(original);
+        const parsedTarget = parseSystemProxySnapshot(target);
+        if (parsedCurrent.platform !== parsedOriginal.platform ||
+            parsedCurrent.platform !== parsedTarget.platform) {
+            return false;
+        }
+        switch (parsedCurrent.platform) {
+            case "win32":
+                if (parsedOriginal.platform !== "win32" || parsedTarget.platform !== "win32") {
+                    return false;
+                }
+                return (leafIsCompatible(parsedCurrent.proxyEnable, parsedOriginal.proxyEnable, parsedTarget.proxyEnable) &&
+                    leafIsCompatible(parsedCurrent.proxyServer, parsedOriginal.proxyServer, parsedTarget.proxyServer) &&
+                    leafIsCompatible(parsedCurrent.proxyOverride, parsedOriginal.proxyOverride, parsedTarget.proxyOverride) &&
+                    leafIsCompatible(parsedCurrent.autoConfigUrl, parsedOriginal.autoConfigUrl, parsedTarget.autoConfigUrl));
+            case "darwin":
+                if (parsedOriginal.platform !== "darwin" || parsedTarget.platform !== "darwin") {
+                    return false;
+                }
+                if (!sameDarwinServices(parsedCurrent, parsedOriginal) ||
+                    !sameDarwinServices(parsedCurrent, parsedTarget)) {
+                    return false;
+                }
+                for (let index = 0; index < parsedCurrent.services.length; index++) {
+                    const currentService = parsedCurrent.services[index];
+                    const originalService = parsedOriginal.services[index];
+                    const targetService = parsedTarget.services[index];
+                    if (!currentService || !originalService || !targetService)
+                        return false;
+                    if (!darwinSettingIsCompatible(currentService.web, originalService.web, targetService.web) ||
+                        !darwinSettingIsCompatible(currentService.secureWeb, originalService.secureWeb, targetService.secureWeb) ||
+                        !darwinSettingIsCompatible(currentService.socks, originalService.socks, targetService.socks) ||
+                        !darwinAutoSettingIsCompatible(currentService.auto, originalService.auto, targetService.auto)) {
+                        return false;
+                    }
+                }
+                return true;
+            case "linux":
+                if (parsedOriginal.platform !== "linux" || parsedTarget.platform !== "linux") {
+                    return false;
+                }
+                return (leafIsCompatible(parsedCurrent.mode, parsedOriginal.mode, parsedTarget.mode) &&
+                    leafIsCompatible(parsedCurrent.autoConfigUrl, parsedOriginal.autoConfigUrl, parsedTarget.autoConfigUrl) &&
+                    leafIsCompatible(parsedCurrent.httpUseAuthentication, parsedOriginal.httpUseAuthentication, parsedTarget.httpUseAuthentication) &&
+                    linuxEndpointIsCompatible(parsedCurrent.http, parsedOriginal.http, parsedTarget.http) &&
+                    linuxEndpointIsCompatible(parsedCurrent.https, parsedOriginal.https, parsedTarget.https) &&
+                    linuxEndpointIsCompatible(parsedCurrent.socks, parsedOriginal.socks, parsedTarget.socks));
+        }
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sysproxy/types.js

@@ -0,0 +1,24 @@
+export const DEFAULT_BYPASS_LIST = [
+    "localhost",
+    "127.*",
+    "10.*",
+    "172.16.*",
+    "172.17.*",
+    "172.18.*",
+    "172.19.*",
+    "172.20.*",
+    "172.21.*",
+    "172.22.*",
+    "172.23.*",
+    "172.24.*",
+    "172.25.*",
+    "172.26.*",
+    "172.27.*",
+    "172.28.*",
+    "172.29.*",
+    "172.30.*",
+    "172.31.*",
+    "192.168.*",
+    "<local>",
+];
+export const SYSTEM_PROXY_SNAPSHOT_VERSION = 1;