@astralyn/sash 0.1.0 → 0.1.2

package/dist/settings.js

@@ -1,301 +1,29 @@
 import crypto from "node:crypto";
-import fs from "node:fs";
-import { atomicWriteFileSync } from "./fs-atomic.js";
 import { isPlainObject } from "./json-shape.js";
-import { sashLayout } from "./paths.js";
-import { acquireStateLockSync } from "./state-lock.js";
-const PUBLIC_SETTINGS_KEYS = [
-    "mixedPort",
-    "controller",
-    "tun",
-    "allowLan",
-    "daemonPort",
-    "systemProxy",
-];
-function exhaustiveKeys() {
-    return (keys) => keys;
-}
-const CANONICAL_SETTINGS_KEYS = exhaustiveKeys()([
-    "schemaVersion",
-    "subscriptionUrl",
-    "mixedPort",
-    "controller",
-    "secret",
-    "tun",
-    "allowLan",
-    "daemonPort",
-    "daemonSecret",
-    "systemProxy",
-]);
-const LEGACY_SETTINGS_KEYS = ["coreVersion", "uiVersion"];
-const ACCEPTED_SETTINGS_KEYS = new Set([
-    ...CANONICAL_SETTINGS_KEYS,
-    ...LEGACY_SETTINGS_KEYS,
-]);
-export function publicSettings(settings) {
-    return {
-        mixedPort: settings.mixedPort,
-        controller: settings.controller,
-        tun: settings.tun,
-        allowLan: settings.allowLan,
-        daemonPort: settings.daemonPort,
-        systemProxy: settings.systemProxy,
-    };
-}
-export function sameSettings(a, b) {
-    return CANONICAL_SETTINGS_KEYS.every((key) => a[key] === b[key]);
-}
+const development = process.env.SASH_DEVELOPMENT === "1";
 export const DEFAULT_SETTINGS = {
-    schemaVersion: 1,
-    mixedPort: 7890,
-    controller: "127.0.0.1:9090",
+    mixedPort: development ? 18890 : 7890,
+    controller: development ? "127.0.0.1:18990" : "127.0.0.1:9090",
     secret: "",
-    tun: false,
     allowLan: false,
-    daemonPort: 19090,
+    daemonPort: development ? 28990 : 19090,
     daemonSecret: "",
     systemProxy: false,
 };
-function hasOwn(object, key) {
-    return Object.hasOwn(object, key);
-}
-function invalidSettings(file, message) {
-    return new Error(`Settings are invalid: ${file}: ${message}`);
-}
-function readRequiredField(source, key, defaultValue, allowMissing, file, parse) {
-    if (!hasOwn(source, key)) {
-        if (!allowMissing)
-            throw invalidSettings(file, `${key} is required`);
-        return { value: defaultValue, missing: true };
-    }
-    const value = source[key];
-    if (value === null)
-        throw invalidSettings(file, `${key} must not be null`);
-    return { value: parse(value, key, file), missing: false };
-}
-function readOptionalString(source, key, file) {
-    if (!hasOwn(source, key))
-        return undefined;
-    const value = source[key];
-    if (value === null)
-        throw invalidSettings(file, `${key} must not be null`);
-    return parseString(value, key, file);
-}
-function parseString(value, key, file) {
-    if (typeof value !== "string")
-        throw invalidSettings(file, `${key} must be a string`);
-    return value;
-}
-function hasSecretControlCharacter(secret) {
-    for (const char of secret) {
-        const code = char.charCodeAt(0);
-        if (code <= 31 || code === 127)
-            return true;
-    }
-    return false;
-}
-function parseSecret(value, key, file) {
-    const secret = parseString(value, key, file);
-    if (!secret.trim())
-        throw invalidSettings(file, `${key} must not be blank`);
-    if (hasSecretControlCharacter(secret)) {
-        throw invalidSettings(file, `${key} must not contain control characters`);
-    }
-    return secret;
-}
-function parseBoolean(value, key, file) {
-    if (typeof value !== "boolean")
-        throw invalidSettings(file, `${key} must be a boolean`);
-    return value;
-}
-function parsePort(value, key, file) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 65_535) {
-        throw invalidSettings(file, `${key} must be an integer from 1 to 65535`);
-    }
-    return value;
-}
-function parseController(value, key, file) {
-    const controller = parseString(value, key, file);
-    const address = parseControllerAddress(controller);
-    if (!address) {
-        throw invalidSettings(file, `${key} must be a loopback host:port controller address`);
-    }
-    return address.canonical;
-}
-function validateSettingsRelations(settings, file) {
-    const controller = parseControllerAddress(settings.controller);
-    if (!controller) {
-        throw invalidSettings(file, "controller must be a loopback host:port controller address");
-    }
-    const ports = [
-        ["mixedPort", settings.mixedPort],
-        ["daemonPort", settings.daemonPort],
-        ["controller", controller.port],
-    ];
-    for (let i = 0; i < ports.length; i++) {
-        for (let j = i + 1; j < ports.length; j++) {
-            if (ports[i]?.[1] === ports[j]?.[1]) {
-                throw invalidSettings(file, `${ports[i]?.[0]} and ${ports[j]?.[0]} must use different ports`);
-            }
-        }
-    }
-}
-function parseSchemaVersion(source, allowMissing, file) {
-    if (!hasOwn(source, "schemaVersion")) {
-        if (!allowMissing)
-            throw invalidSettings(file, "schemaVersion is required");
-        return { value: 0, missing: true };
-    }
-    const value = source.schemaVersion;
-    if (value === null)
-        throw invalidSettings(file, "schemaVersion must not be null");
-    if (typeof value !== "number" || !Number.isInteger(value)) {
-        throw invalidSettings(file, "schemaVersion must be an integer");
-    }
-    if (value === 0 || value === 1)
-        return { value, missing: false };
-    if (value > 1) {
-        throw invalidSettings(file, `schemaVersion ${value} is from a future version`);
-    }
-    throw invalidSettings(file, "schemaVersion must be 0 or 1");
-}
-function parseSettings(document, file, allowMissing) {
-    if (!isPlainObject(document)) {
-        throw invalidSettings(file, "JSON root must be a plain object");
-    }
-    for (const key of Object.keys(document)) {
-        if (!ACCEPTED_SETTINGS_KEYS.has(key)) {
-            throw invalidSettings(file, `unknown field ${JSON.stringify(key)}`);
-        }
-    }
-    const schemaVersion = parseSchemaVersion(document, allowMissing, file);
-    const subscriptionUrl = readOptionalString(document, "subscriptionUrl", file);
-    const mixedPort = readRequiredField(document, "mixedPort", DEFAULT_SETTINGS.mixedPort, allowMissing, file, parsePort);
-    const controller = readRequiredField(document, "controller", DEFAULT_SETTINGS.controller, allowMissing, file, parseController);
-    const secret = readRequiredField(document, "secret", DEFAULT_SETTINGS.secret, allowMissing, file, parseSecret);
-    const tun = readRequiredField(document, "tun", DEFAULT_SETTINGS.tun, allowMissing, file, parseBoolean);
-    const allowLan = readRequiredField(document, "allowLan", DEFAULT_SETTINGS.allowLan, allowMissing, file, parseBoolean);
-    const daemonPort = readRequiredField(document, "daemonPort", DEFAULT_SETTINGS.daemonPort, allowMissing, file, parsePort);
-    const daemonSecret = readRequiredField(document, "daemonSecret", DEFAULT_SETTINGS.daemonSecret, allowMissing, file, parseSecret);
-    const systemProxy = readRequiredField(document, "systemProxy", DEFAULT_SETTINGS.systemProxy, allowMissing, file, parseBoolean);
-    let needsRewrite = schemaVersion.missing ||
-        schemaVersion.value === 0 ||
-        mixedPort.missing ||
-        controller.missing ||
-        controller.value !== document.controller ||
-        secret.missing ||
-        tun.missing ||
-        allowLan.missing ||
-        daemonPort.missing ||
-        daemonSecret.missing ||
-        systemProxy.missing;
-    for (const key of LEGACY_SETTINGS_KEYS) {
-        if (!hasOwn(document, key))
-            continue;
-        const value = document[key];
-        if (value === null)
-            throw invalidSettings(file, `${key} must not be null`);
-        parseString(value, key, file);
-        needsRewrite = true;
-    }
-    const normalizedSecret = secret.missing ? generateSecret() : secret.value;
-    const normalizedDaemonSecret = daemonSecret.missing ? generateSecret() : daemonSecret.value;
-    const settings = {
-        schemaVersion: 1,
-        mixedPort: mixedPort.value,
-        controller: controller.value,
-        secret: normalizedSecret,
-        tun: tun.value,
-        allowLan: allowLan.value,
-        daemonPort: daemonPort.value,
-        daemonSecret: normalizedDaemonSecret,
-        systemProxy: systemProxy.value,
-    };
-    if (subscriptionUrl !== undefined)
-        settings.subscriptionUrl = subscriptionUrl;
-    validateSettingsRelations(settings, file);
-    return { settings, needsRewrite };
+export function generateSecret() {
+    return crypto.randomBytes(24).toString("hex");
 }
-function readSettingsFile(file) {
-    let text;
-    try {
-        text = fs.readFileSync(file, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT") {
-            return { exists: false, document: {} };
-        }
-        throw err;
-    }
-    try {
-        return { exists: true, document: JSON.parse(text) };
-    }
-    catch (err) {
-        throw new Error(`Settings file is invalid JSON: ${file}: ${err instanceof Error ? err.message : String(err)}`);
-    }
+export function initialSettings() {
+    return { ...DEFAULT_SETTINGS, secret: generateSecret(), daemonSecret: generateSecret() };
 }
-function canonicalSettings(settings) {
-    const canonical = {
-        schemaVersion: 1,
+export function publicSettings(settings) {
+    return {
         mixedPort: settings.mixedPort,
         controller: settings.controller,
-        secret: settings.secret,
-        tun: settings.tun,
         allowLan: settings.allowLan,
         daemonPort: settings.daemonPort,
-        daemonSecret: settings.daemonSecret,
         systemProxy: settings.systemProxy,
     };
-    if (settings.subscriptionUrl !== undefined)
-        canonical.subscriptionUrl = settings.subscriptionUrl;
-    return canonical;
-}
-function writeCanonicalSettings(settings, layout) {
-    atomicWriteFileSync(layout.settingsFile, `${JSON.stringify(canonicalSettings(settings), null, 2)}\n`);
-}
-function loadSettingsUnlocked(layout) {
-    const source = readSettingsFile(layout.settingsFile);
-    const parsed = parseSettings(source.document, layout.settingsFile, true);
-    if (!source.exists || parsed.needsRewrite) {
-        writeCanonicalSettings(parsed.settings, layout);
-    }
-    return parsed.settings;
-}
-export function generateSecret() {
-    return crypto.randomBytes(24).toString("hex");
-}
-export function loadSettings(layout = sashLayout()) {
-    const lease = acquireStateLockSync(layout.settingsLockFile, { purpose: "settings" });
-    try {
-        return loadSettingsUnlocked(layout);
-    }
-    finally {
-        lease.release();
-    }
-}
-export function saveSettings(settings, layout = sashLayout()) {
-    const lease = acquireStateLockSync(layout.settingsLockFile, { purpose: "settings" });
-    try {
-        const parsed = parseSettings(settings, layout.settingsFile, false);
-        writeCanonicalSettings(parsed.settings, layout);
-        return parsed.settings;
-    }
-    finally {
-        lease.release();
-    }
-}
-export function parseSettingsText(text, file = "sash.json") {
-    let document;
-    try {
-        document = JSON.parse(text);
-    }
-    catch (err) {
-        throw new Error(`Settings file is invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    return parseSettings(document, file, false).settings;
-}
-export function validateSettingsCandidate(candidate) {
-    return parseSettings(candidate, "candidate settings", false).settings;
 }
 export function parseControllerAddress(value) {
     const match = value.trim().match(/^(127\.0\.0\.1|localhost|\[::1\]):(\d+)$/i);
@@ -303,12 +31,60 @@ export function parseControllerAddress(value) {
     const rawPort = match?.[2];
     if (!rawHost || !rawPort)
         return undefined;
-    const port = Number.parseInt(rawPort, 10);
+    const port = Number(rawPort);
     if (port < 1 || port > 65_535 || String(port) !== rawPort)
         return undefined;
-    if (rawHost === "[::1]") {
+    if (rawHost === "[::1]")
         return { host: "::1", port, canonical: `[::1]:${port}` };
-    }
     const host = rawHost === "localhost" ? "localhost" : "127.0.0.1";
     return { host, port, canonical: `${host}:${port}` };
 }
+export function validateSettingsCandidate(value) {
+    if (!isPlainObject(value))
+        throw new Error("Settings must be a plain object");
+    const keys = Object.keys(DEFAULT_SETTINGS);
+    if (Object.keys(value).some((key) => !keys.includes(key))) {
+        throw new Error("Settings contain an unknown field");
+    }
+    for (const key of keys) {
+        if (!Object.hasOwn(value, key))
+            throw new Error(`Settings field ${key} is required`);
+    }
+    const port = (key) => {
+        const number = value[key];
+        if (typeof number !== "number" || !Number.isInteger(number) || number < 1 || number > 65_535) {
+            throw new Error(`${key} must be an integer from 1 to 65535`);
+        }
+        return number;
+    };
+    const secret = (key) => {
+        const text = value[key];
+        if (typeof text !== "string" || !text.trim())
+            throw new Error(`${key} must not be blank`);
+        if ([...text].some((char) => char.charCodeAt(0) <= 31 || char.charCodeAt(0) === 127)) {
+            throw new Error(`${key} must not contain control characters`);
+        }
+        return text;
+    };
+    const boolean = (key) => {
+        if (typeof value[key] !== "boolean")
+            throw new Error(`${key} must be a boolean`);
+        return value[key];
+    };
+    const controller = typeof value.controller === "string" && parseControllerAddress(value.controller);
+    if (!controller)
+        throw new Error("controller must be a loopback host:port address");
+    const result = {
+        mixedPort: port("mixedPort"),
+        controller: controller.canonical,
+        secret: secret("secret"),
+        allowLan: boolean("allowLan"),
+        daemonPort: port("daemonPort"),
+        daemonSecret: secret("daemonSecret"),
+        systemProxy: boolean("systemProxy"),
+    };
+    if (new Set([result.mixedPort, result.daemonPort, controller.port]).size !== 3) {
+        throw new Error("mixedPort, daemonPort and controller must use different ports");
+    }
+    return result;
+}

package/dist/status.js

@@ -1,10 +1,11 @@
+import { AutostartService } from "./autostart.js";
 import { currentCoreVersion } from "./core.js";
 import { SashDaemonClient } from "./daemon-client.js";
 import { evaluateDaemon, } from "./daemon-lifecycle.js";
-import { ProfileService } from "./profile-service.js";
+import { getActiveProfile, loadProfiles } from "./profiles.js";
 import { SystemProxyManager } from "./system-proxy-manager.js";
 import { uiInstalled } from "./webui.js";
-export const CLI_STATUS_SCHEMA_VERSION = 1;
+export const CLI_STATUS_SCHEMA_VERSION = 2;
 function errorText(err) {
     const message = err instanceof Error ? err.message : String(err);
     return (message
@@ -106,16 +107,13 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
         : currentCoreVersion(context.layout);
     const profile = dependencies.activeProfile
         ? dependencies.activeProfile(context)
-        : new ProfileService({
-            layout: context.layout,
-            settings: () => context.settings,
-        }).active();
+        : getActiveProfile(loadProfiles(context.layout));
     let coreRunning = daemonState.running ? null : false;
     let coreHealthy = daemonState.running ? null : false;
     let corePid = null;
     let coreVersion = null;
-    let tunActive = daemonState.running ? null : false;
     let desiredProxy = context.settings.systemProxy;
+    let mixedEndpoint = `127.0.0.1:${context.settings.mixedPort}`;
     let proxySource;
     let queriedDaemon = false;
     if (daemonState.kind === "healthy") {
@@ -124,6 +122,11 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
             queriedDaemon = true;
             daemon = daemonObservation(daemonState, "healthy");
             desiredProxy = status.systemProxy.desired;
+            mixedEndpoint = status.core.running
+                ? status.configuration.appliedSettings
+                    ? `127.0.0.1:${status.configuration.appliedSettings.mixedPort}`
+                    : "unknown"
+                : `127.0.0.1:${status.settings.mixedPort}`;
             proxySource = {
                 applied: status.systemProxy.applied,
                 appliedKnown: status.systemProxy.appliedKnown,
@@ -137,7 +140,6 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
             else if (!status.core.running) {
                 coreRunning = false;
                 coreHealthy = false;
-                tunActive = false;
             }
             else {
                 coreRunning = true;
@@ -147,7 +149,6 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
                     typeof status.core.version === "string" && status.core.version
                         ? status.core.version
                         : null;
-                tunActive = typeof status.core.tunActive === "boolean" ? status.core.tunActive : null;
                 if (coreHealthy === null)
                     addError(errors, "Core health is unavailable");
                 else if (!coreHealthy)
@@ -156,8 +157,6 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
                     addError(errors, "Core PID is unavailable");
                 if (coreVersion === null)
                     addError(errors, "Core runtime version is unavailable");
-                if (tunActive === null)
-                    addError(errors, "Core TUN state is unavailable");
             }
         }
         catch (err) {
@@ -179,11 +178,24 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
             : null;
     const activeProfile = profile ? { id: profile.id, name: profile.name, url: profile.url } : null;
     const daemonPort = daemon.port || context.settings.daemonPort;
+    let autostart;
+    try {
+        autostart = await (dependencies.inspectAutostart
+            ? dependencies.inspectAutostart(context)
+            : new AutostartService({ layout: context.layout }).inspect());
+    }
+    catch (error) {
+        autostart = { state: "unknown", canEnable: false, reason: errorText(error) };
+    }
+    if (autostart.state === "unknown") {
+        addError(errors, `Autostart query failed: ${autostart.reason ?? "unknown error"}`);
+    }
     return {
         schemaVersion: CLI_STATUS_SCHEMA_VERSION,
         complete: errors.length === 0,
         healthy,
         queryError: errors.length > 0 ? errors.join("; ") : null,
+        autostart,
         daemon: { ...daemon, port: daemonPort },
         core: {
             running: coreRunning,
@@ -199,16 +211,12 @@ export async function collectRuntimeStatus(context, dependencies = {}) {
         },
         uiInstalled: dependencies.hasUi ? dependencies.hasUi(context) : uiInstalled(context.layout),
         endpoints: {
-            mixedProxy: `127.0.0.1:${context.settings.mixedPort}`,
+            mixedProxy: mixedEndpoint,
             controller: context.settings.controller,
             daemonApi: `http://127.0.0.1:${daemonPort}`,
             dashboard: `http://127.0.0.1:${daemonPort}/ui/`,
         },
         activeProfile,
-        tun: {
-            desired: context.settings.tun,
-            active: tunActive,
-        },
         paths: {
             root: context.layout.root,
             config: context.layout.configFile,
@@ -243,30 +251,6 @@ export function runtimeStatusHeadline(status) {
         text: `sashd running (PID=${status.daemon.pid}), core stopped`,
     };
 }
-export function formatTunObservation(status) {
-    if (!status.tun.desired) {
-        if (status.tun.active === true)
-            return "off (runtime active)";
-        return status.tun.active === null && status.core.running !== false
-            ? "off (runtime unknown)"
-            : "off";
-    }
-    if (status.core.running === false)
-        return "on (core stopped)";
-    if (status.core.running === null)
-        return "on (runtime unknown)";
-    if (status.tun.active === true)
-        return "on (active)";
-    if (status.tun.active === false)
-        return "on (inactive)";
-    return "on (unverified)";
-}
-export function shouldShowTunGuidance(status) {
-    return (status.tun.desired &&
-        status.core.running === true &&
-        status.core.healthy === true &&
-        status.tun.active !== true);
-}
 export function formatObservedProxy(state) {
     if (state.enabled === null)
         return "unknown";

package/dist/supervisor.js

@@ -79,14 +79,6 @@ export class CoreSupervisor {
         }
         return terminated;
     }
-    async probeTunActive(api) {
-        try {
-            return await api.getTunActive();
-        }
-        catch {
-            return undefined;
-        }
-    }
     async start() {
         if (this.child && this.isAlive(this.child.pid ?? -1)) {
             throw new Error(`Core is already running (PID=${this.child.pid})`);
@@ -166,12 +158,10 @@ export class CoreSupervisor {
                 }
                 healthyProbes++;
                 if (healthyProbes >= 2 && this.isAlive(pid)) {
-                    const tunActive = await this.probeTunActive(api);
                     if (this.isAlive(pid)) {
                         return {
                             pid,
                             version,
-                            ...(tunActive !== undefined ? { tunActive } : {}),
                         };
                     }
                 }
@@ -241,13 +231,11 @@ export class CoreSupervisor {
         const api = new MihomoApi(settings.controller, settings.secret);
         let healthy = false;
         let version;
-        let tunActive;
         try {
-            version = await api.version();
+            version = await api.version({ deadlineMs: 1000, attempts: 1 });
             healthy = true;
             if (!this.ownsCore(ownership))
                 return { running: false };
-            tunActive = await this.probeTunActive(api);
         }
         catch {
             healthy = false;
@@ -260,7 +248,6 @@ export class CoreSupervisor {
             startedAt: this.childStartedAt,
             healthy,
             version,
-            ...(tunActive !== undefined ? { tunActive } : {}),
         };
     }
     isRunning() {

package/dist/sysproxy/common.js

@@ -1,9 +1,8 @@
 import { errorMessage } from "../error-utils.js";
 import { isPlainObject } from "../json-shape.js";
-import { findExecutableOnPath, runSanitizedCommandAsync, windowsSystemExecutable, } from "../process.js";
+import { runSanitizedCommandAsync, windowsSystemExecutable } from "../process.js";
 import { DEFAULT_BYPASS_LIST } from "./types.js";
 const MAX_PROXY_STRING_LENGTH = 4096;
-const MAX_SERVICE_NAME_LENGTH = 512;
 export { errorMessage, isPlainObject };
 export function parseProxyString(value, label, allowEmpty = true) {
     if (typeof value !== "string") {
@@ -20,19 +19,6 @@ export function parseProxyString(value, label, allowEmpty = true) {
     }
     return value;
 }
-export function parseServiceName(value, label) {
-    const service = parseProxyString(value, label, false);
-    if (service.length > MAX_SERVICE_NAME_LENGTH) {
-        throw new Error(`Invalid system proxy snapshot: ${label} has an invalid length`);
-    }
-    return service;
-}
-export function parseSnapshotPort(value, label) {
-    if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 65_535) {
-        throw new Error(`Invalid system proxy snapshot: ${label} must be an integer from 0 to 65535`);
-    }
-    return value;
-}
 export function parseProxyEnable(value) {
     if (value === null)
         return null;
@@ -41,37 +27,8 @@ export function parseProxyEnable(value) {
     }
     return value;
 }
-export function compareStrings(a, b) {
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    return 0;
-}
-export function isSystemProxySupported(platform = process.platform) {
-    if (platform === "win32" || platform === "darwin")
-        return true;
-    if (platform !== "linux")
-        return false;
-    return findExecutableOnPath("gsettings") !== undefined;
-}
-function resolveSystemProxyCommand(command) {
-    if (process.platform === "win32" && command.toLowerCase() === "reg.exe") {
-        return windowsSystemExecutable("reg.exe");
-    }
-    if (process.platform === "darwin" && command === "networksetup") {
-        return "/usr/sbin/networksetup";
-    }
-    if (process.platform === "linux" && command === "gsettings") {
-        const resolved = findExecutableOnPath(command);
-        if (!resolved)
-            throw new Error("gsettings is not available on this system");
-        return resolved;
-    }
-    return command;
-}
 export function runCmd(cmd, args, timeoutMs = 5000) {
-    return runSanitizedCommandAsync(resolveSystemProxyCommand(cmd), args, { timeoutMs });
+    return runSanitizedCommandAsync(cmd.toLowerCase() === "reg.exe" ? windowsSystemExecutable("reg.exe") : cmd, args, { timeoutMs });
 }
 export function normalizeEnableOptions(opts) {
     if (!isPlainObject(opts)) {
@@ -97,3 +54,6 @@ export function normalizeEnableOptions(opts) {
 export function formatHostPort(host, port) {
     return host.includes(":") && !host.startsWith("[") ? `[${host}]:${port}` : `${host}:${port}`;
 }
+export function isSystemProxySupported(platform = process.platform) {
+    return platform === "win32";
+}