march-cli 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",
@@ -32,6 +32,7 @@
     "node-notifier": "^10.0.1",
     "node-pty": "^1.1.0",
     "typebox": "^1.0.58",
+    "undici": "^7.25.0",
     "web-tree-sitter": "^0.26.8"
   },
   "optionalDependencies": {

package/src/agent/file-edit-tool.mjs

@@ -5,7 +5,7 @@ import { Type } from "typebox";
 import { toolText } from "./tool-result.mjs";
 import { applyReplaceTextPatch, applyReplaceRangePatch } from "./editing/diff-apply.mjs";
 import { formatAppliedDiff, formatDiff } from "./editing/diff-format.mjs";
-import { buildDiagnosticsForPath } from "../context/diagnostics.mjs";
+import { formatLspDiagnosticsForPath } from "../lsp/diagnostics-format.mjs";
 
 export { formatDiff } from "./editing/diff-format.mjs";
 
@@ -117,7 +117,7 @@ async function waitForDiagnosticsForPath({ lspService, path, timeoutMs, interval
   if (!lspService?.snapshot || !path) return "";
   const deadline = Date.now() + timeoutMs;
   for (;;) {
-    const diagnostics = buildDiagnosticsForPath({ snapshot: lspService.snapshot(), path });
+    const diagnostics = formatLspDiagnosticsForPath({ snapshot: lspService.snapshot(), path });
     if (diagnostics) return diagnostics;
     const remaining = deadline - Date.now();
     if (remaining <= 0) return "";

package/src/agent/runner.mjs

@@ -8,6 +8,7 @@ import { ContextEngine } from "../context/engine.mjs";
 import { createMarchLifecycleAdapter } from "../extensions/lifecycle-adapter.mjs";
 import { syncPiSessionSidecar } from "../session/sidecar-sync.mjs";
 import { LspService } from "../lsp/service.mjs";
+import { formatLspServiceEvent } from "../lsp/status-message.mjs";
 import { formatRecallHints } from "../memory/markdown-store.mjs";
 import { appendProviderUserMessage, estimateProviderPayloadTokens, installModelPayloadDumper, replaceProviderContextMessages } from "./model-payload-dumper.mjs";
 import { resolveInitialModel, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
@@ -48,7 +49,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     compaction: { enabled: false },
     retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
   });
-  const lspService = new LspService({ cwd });
+  const lspService = new LspService({ cwd, onEvent: (event) => ui.status?.(formatLspServiceEvent(event)) });
   const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, centerMemoryPath, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
@@ -218,6 +219,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     },
     getExtensionDiagnostics() { return runtimeHost?.getDiagnostics?.() ?? []; },
     getExtensionLifecycleState() { return lifecycleAdapter.getState(); },
+    getLspStatus() { return lspService.snapshot(); },
     async switchPiSession(sessionPath) {
       if (!runtimeHost) throw new Error("pi runtime host is not enabled");
       nextTurnContextMode = "rebuild";

package/src/cli/commands/status-command.mjs

@@ -31,6 +31,7 @@ export function statusBarLine({
   mode = MODES.DO,
   contextTokens = null,
   activity = null,
+  lspStatus = null,
 }) {
   return formatStatusBarLine({
     engine: runner.engine,
@@ -43,6 +44,7 @@ export function statusBarLine({
     mode,
     contextTokens,
     activity,
+    lspStatus,
   });
 }
 
@@ -80,6 +82,7 @@ export function formatStatusBarLine({
   mode = MODES.DO,
   contextTokens = null,
   activity = null,
+  lspStatus = null,
 }) {
   const model = engine.modelId || "model?";
   const thinking = engine.thinkingLevel || "thinking?";
@@ -91,6 +94,8 @@ export function formatStatusBarLine({
   const modeSegment = `${mode === MODES.DISCUSS ? WARN : OK}${formatModeLabel(mode)}`;
   const runtime = `${C.cyan}${model}${DIM}·${thinking}`;
   const segments = [modeSegment, runtime];
+  const lspText = formatLspSegment(lspStatus);
+  if (lspText) segments.push(`${C.fg250}${lspText}`);
   const activityText = formatActivitySegment(activity);
   if (activityText) segments.push(`${C.fg250}${activityText}`);
   const compactTokens = formatCompactTokenCount(contextTokens);
@@ -100,6 +105,42 @@ export function formatStatusBarLine({
   return `${inner}${R}`;
 }
 
+export function formatLspSegment(lspStatus) {
+  if (!lspStatus) return "";
+  const servers = lspStatus.servers ?? [];
+  const visible = servers.filter((server) => server.id);
+  if (visible.length === 0) return "lsp:off";
+  const parts = buildLspStatusParts(visible);
+  if (parts.length === 0) return "lsp:off";
+  return `lsp:${parts.join(",")}`;
+}
+
+function buildLspStatusParts(servers) {
+  const byId = new Map();
+  for (const server of servers) {
+    const id = shortLspId(server.id);
+    byId.set(id, mergeLspStatus(byId.get(id), server.status));
+  }
+  return [...byId.entries()]
+    .filter(([, status]) => status !== "unavailable")
+    .map(([id, status]) => `${id}${formatLspStatusMark(status)}`);
+}
+
+function mergeLspStatus(current, next) {
+  const rank = { failed: 4, starting: 3, busy: 2, ready: 1, idle: 1, unavailable: 0 };
+  if (!current) return next ?? "unavailable";
+  const currentRank = rank[current] ?? 0;
+  const nextRank = rank[next] ?? 0;
+  return nextRank > currentRank ? next : current;
+}
+
+function formatLspStatusMark(status) {
+  if (status === "failed") return "!";
+  if (status === "starting") return "…";
+  if (status === "unavailable") return "";
+  return "✓";
+}
+
 function formatActivitySegment(activity) {
   if (!activity) return "";
   const label = String(activity.label ?? "").trim();
@@ -107,6 +148,11 @@ function formatActivitySegment(activity) {
   return [frame, label].filter(Boolean).join(" ");
 }
 
+function shortLspId(id) {
+  if (id === "typescript") return "ts";
+  return String(id ?? "?");
+}
+
 export function formatCompactTokenCount(tokens) {
   const value = Number(tokens);
   if (!Number.isFinite(value) || value <= 0) return "";

package/src/cli/input/select-with-keyboard.mjs

@@ -45,7 +45,12 @@ export async function selectWithKeyboard({ input = process.stdin, output = proce
       input.off("data", onData);
       input.setRawMode(false);
       input.pause();
-      if (renderedLines > 0) output.write(`\x1b[${renderedLines}F`);
+      if (renderedLines > 0) {
+        output.write(`\x1b[${renderedLines}F`);
+        // clear all previously rendered lines
+        for (let i = 0; i < renderedLines; i++) output.write("\x1b[2K\r\n");
+        output.write(`\x1b[${renderedLines}F`);
+      }
       // final render shows just the selected item
       const lines = formatSelectionList({ message, items, selected, viewportStart: 0, viewportEnd: items.length, done: value != null });
       output.write(`\x1b[2K\r${lines[0]}\n`);

package/src/cli/status-line-updater.mjs

@@ -27,6 +27,7 @@ export function createStatusLineUpdater({
       mode: getMode(),
       contextTokens,
       activity: formatActivity(activity, frameIndex),
+      lspStatus: runner.getLspStatus?.() ?? null,
     });
     ui.setStatusBar(line);
     return line;

package/src/config/loader.mjs

@@ -46,6 +46,7 @@ function mergeLayers(layers) {
     serviceTier: null,
     providers: {},
     webSearch: { provider: null, providers: {} },
+    network: { proxy: "system", ca: "system" },
     maxTurns: null,
     trimBatch: null,
     memoryRoot: null,
@@ -69,6 +70,12 @@ function mergeLayers(layers) {
         ...layer.notifications,
       };
     }
+    if (layer.network && typeof layer.network === "object" && !Array.isArray(layer.network)) {
+      result.network = {
+        ...result.network,
+        ...layer.network,
+      };
+    }
     if (layer.memoryRoot) result.memoryRoot = layer.memoryRoot;
   }
 

package/src/{context/diagnostics.mjs → lsp/diagnostics-format.mjs}

@@ -1,6 +1,6 @@
 const MAX_DIAGNOSTICS = 20;
 
-export function buildDiagnosticsLayer({ snapshot } = {}) {
+export function formatLspDiagnostics({ snapshot } = {}) {
   const diagnostics = snapshot?.diagnostics ?? [];
   if (diagnostics.length === 0) return "[diagnostics]";
 
@@ -17,12 +17,12 @@ export function buildDiagnosticsLayer({ snapshot } = {}) {
   return lines.join("\n");
 }
 
-export function buildDiagnosticsForPath({ snapshot, path } = {}) {
+export function formatLspDiagnosticsForPath({ snapshot, path } = {}) {
   const targetPath = String(path ?? "");
   if (!targetPath) return "";
   const diagnostics = (snapshot?.diagnostics ?? []).filter((diagnostic) => diagnostic.path === targetPath);
   if (diagnostics.length === 0) return "";
-  return buildDiagnosticsLayer({
+  return formatLspDiagnostics({
     snapshot: {
       ...snapshot,
       diagnostics,

package/src/lsp/servers.mjs

@@ -11,7 +11,11 @@ const LSP_SERVERS = [
     rootMarkers: NODE_ROOT_MARKERS,
     command: ["vue-language-server"],
     args: ["--stdio"],
-    initialization: () => ({}),
+    initialization: ({ root, workspaceRoot }) => {
+      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+      return tsdk ? { typescript: { tsdk } } : null;
+    },
+    missingInitialization: "missing project typescript SDK",
   },
   {
     id: "typescript",
@@ -20,10 +24,10 @@ const LSP_SERVERS = [
     command: ["typescript-language-server"],
     args: ["--stdio"],
     initialization: ({ root, workspaceRoot }) => {
-      const tsserver = resolveModule("typescript/lib/tsserver.js", workspaceRoot) ?? resolveModule("typescript/lib/tsserver.js", root);
-      if (!tsserver) return null;
-      return { tsserver: { path: tsserver } };
+      const tsserver = resolveTypeScriptServer({ root, workspaceRoot });
+      return tsserver ? { tsserver: { path: tsserver } } : null;
     },
+    missingInitialization: "missing project typescript/tsserver.js",
   },
   {
     id: "python",
@@ -68,10 +72,10 @@ const LSP_SERVERS = [
     command: ["astro-ls", "@astrojs/language-server"],
     args: ["--stdio"],
     initialization: ({ root, workspaceRoot }) => {
-      const tsserver = resolveModule("typescript/lib/tsserver.js", workspaceRoot) ?? resolveModule("typescript/lib/tsserver.js", root);
-      if (!tsserver) return null;
-      return { typescript: { tsdk: dirname(tsserver) } };
+      const tsdk = resolveTypeScriptSdk({ root, workspaceRoot });
+      return tsdk ? { typescript: { tsdk } } : null;
     },
+    missingInitialization: "missing project typescript SDK",
   },
   {
     id: "yaml",
@@ -126,23 +130,30 @@ const LSP_SERVERS = [
 ];
 
 export function resolveLspServer({ filePath, workspaceRoot }) {
+  const result = resolveLspServerStatus({ filePath, workspaceRoot });
+  return result.status === "available" ? result.server : null;
+}
+
+export function resolveLspServerStatus({ filePath, workspaceRoot }) {
   const ext = extensionOf(filePath);
   const def = LSP_SERVERS.find((server) => server.extensions.includes(ext));
-  if (!def) return null;
+  if (!def) return { status: "unsupported", extension: ext };
 
   const root = def.rootMarkers.length > 0
     ? findNearestRoot(dirname(filePath), workspaceRoot, def.rootMarkers) ?? workspaceRoot
     : workspaceRoot;
   const command = findCommand(def.command, { root, workspaceRoot });
-  if (!command) return null;
+  if (!command) {
+    return { status: "unavailable", id: def.id, root, reason: `missing ${def.command[0]}` };
+  }
+
   const initialization = def.initialization?.({ root, workspaceRoot }) ?? {};
-  if (initialization === null) return null;
+  if (initialization === null) {
+    return { status: "unavailable", id: def.id, root, reason: def.missingInitialization ?? "missing SDK" };
+  }
   return {
-    id: def.id,
-    command,
-    args: def.args,
-    root,
-    initialization,
+    status: "available",
+    server: { id: def.id, command, args: def.args, root, initialization },
   };
 }
 
@@ -160,7 +171,7 @@ function findCommand(names, { root, workspaceRoot }) {
 
 function findBin(name, { root, workspaceRoot }) {
   const names = platformCommandNames(name);
-  for (const base of [root, workspaceRoot]) {
+  for (const base of uniquePaths([root, workspaceRoot])) {
     for (const bin of names) {
       const candidate = join(base, "node_modules", ".bin", bin);
       if (existsSync(candidate)) return candidate;
@@ -185,6 +196,24 @@ function findOnPath(names) {
   return null;
 }
 
+function resolveTypeScriptServer({ root, workspaceRoot }) {
+  return resolveModuleFromRoots("typescript/lib/tsserver.js", { root, workspaceRoot });
+}
+
+function resolveTypeScriptSdk({ root, workspaceRoot }) {
+  const serverLibrary = resolveModuleFromRoots("typescript/lib/tsserverlibrary.js", { root, workspaceRoot });
+  const tsserver = serverLibrary ?? resolveTypeScriptServer({ root, workspaceRoot });
+  return tsserver ? dirname(tsserver) : null;
+}
+
+function resolveModuleFromRoots(id, { root, workspaceRoot }) {
+  for (const base of uniquePaths([root, workspaceRoot])) {
+    const hit = resolveModule(id, base);
+    if (hit) return hit;
+  }
+  return null;
+}
+
 function resolveModule(id, base) {
   try {
     return createRequire(join(base, "package.json")).resolve(id);
@@ -193,6 +222,10 @@ function resolveModule(id, base) {
   }
 }
 
+function uniquePaths(paths) {
+  return [...new Set(paths.map((path) => resolve(path)))];
+}
+
 function findNearestRoot(start, stop, markers) {
   let dir = resolve(start);
   const boundary = resolve(stop);

package/src/lsp/service.mjs

@@ -1,28 +1,40 @@
 import { LspClient } from "./client.mjs";
 import { LspDiagnosticStore } from "./diagnostic-store.mjs";
-import { resolveLspServer } from "./servers.mjs";
+import { resolveLspServerStatus } from "./servers.mjs";
 
 export class LspService {
-  constructor({ cwd }) {
+  constructor({ cwd, onEvent = null }) {
     this.cwd = cwd;
+    this.onEvent = onEvent;
     this.store = new LspDiagnosticStore();
     this.clients = new Map();
     this.spawning = new Map();
+    this.unavailable = new Map();
+    this.announced = new Set();
   }
 
   touchFile(path) {
-    const server = resolveLspServer({ filePath: path, workspaceRoot: this.cwd });
-    if (!server) return;
+    const result = resolveLspServerStatus({ filePath: path, workspaceRoot: this.cwd });
+    if (result.status === "unsupported") return result;
+    if (result.status === "unavailable") {
+      this.unavailable.set(result.id, result);
+      this.#emitOnce(`unavailable:${result.id}:${result.reason}`, result);
+      return result;
+    }
+
+    const server = result.server;
     const key = `${server.id}:${server.root}`;
     const existing = this.clients.get(key);
     if (existing) {
       existing.touchFile(path);
-      return;
+      return { status: "already_attached", id: server.id, root: server.root };
     }
     if (this.spawning.has(key)) {
       this.spawning.get(key).then((client) => client?.touchFile(path)).catch(() => {});
-      return;
+      return { status: "starting", id: server.id, root: server.root };
     }
+
+    this.#emitOnce(`starting:${key}`, { status: "starting", id: server.id, root: server.root });
     const task = this.#startClient(server, key).then((client) => {
       client?.touchFile(path);
       return client;
@@ -31,13 +43,25 @@ export class LspService {
     task.finally(() => {
       if (this.spawning.get(key) === task) this.spawning.delete(key);
     }).catch(() => {});
+    return { status: "starting", id: server.id, root: server.root };
   }
 
   snapshot() {
     const diagnostics = this.store.snapshot();
-    const statuses = [...this.clients.values()].map((client) => client.status);
-    const status = statuses.includes("busy") ? "busy" : statuses.includes("starting") ? "starting" : statuses.includes("failed") ? "failed" : statuses.length > 0 ? "idle" : "";
-    return { status, diagnostics };
+    const servers = [
+      ...[...this.clients.values()].map((client) => ({
+        id: client.serverId,
+        root: client.cwd,
+        status: client.status,
+      })),
+      ...[...this.spawning.keys()].map((key) => ({
+        id: key.slice(0, key.indexOf(":")),
+        root: key.slice(key.indexOf(":") + 1),
+        status: "starting",
+      })),
+      ...this.unavailable.values(),
+    ];
+    return { status: summarizeStatus(servers), diagnostics, servers };
   }
 
   async dispose() {
@@ -56,10 +80,31 @@ export class LspService {
     try {
       await client.start();
       this.clients.set(key, client);
+      this.unavailable.delete(server.id);
+      this.#emitOnce(`attached:${key}`, { status: "attached", id: server.id, root: server.root });
       return client;
-    } catch {
+    } catch (err) {
       client.status = "failed";
+      const event = { status: "failed", id: server.id, root: server.root, reason: err.message };
+      this.unavailable.set(server.id, event);
+      this.#emitOnce(`failed:${key}:${err.message}`, event);
       return null;
     }
   }
+
+  #emitOnce(key, event) {
+    if (this.announced.has(key)) return;
+    this.announced.add(key);
+    this.onEvent?.(event);
+  }
+}
+
+function summarizeStatus(servers) {
+  const statuses = servers.map((server) => server.status);
+  if (statuses.includes("busy")) return "busy";
+  if (statuses.includes("starting")) return "starting";
+  if (statuses.includes("failed")) return "failed";
+  if (statuses.includes("ready") || statuses.includes("idle")) return "idle";
+  if (statuses.includes("unavailable")) return "unavailable";
+  return "";
 }

package/src/lsp/status-message.mjs

@@ -0,0 +1,8 @@
+export function formatLspServiceEvent(event) {
+  const id = event?.id ? String(event.id) : "server";
+  if (event?.status === "attached") return `LSP attached: ${id}`;
+  if (event?.status === "starting") return `LSP starting: ${id}`;
+  if (event?.status === "failed") return `LSP failed: ${id} - ${event.reason}`;
+  if (event?.status === "unavailable") return `LSP unavailable: ${id} - ${event.reason}`;
+  return `LSP ${event?.status ?? "status"}: ${id}`;
+}

package/src/main.mjs

@@ -33,6 +33,7 @@ import { runProviderConfigCommand } from "./provider/config-command.mjs";
 import { runWebSearchConfigCommand } from "./web/config-command.mjs";
 import { createDesktopTurnNotifier } from "./notification/desktop-notifier.mjs";
 import { registerSuperGrokOAuthProvider } from "./supergrok/oauth-provider.mjs";
+import { installNetworkEnvironment } from "./network/environment.mjs";
 
 export async function run(argv) {
   const cwd = process.cwd();
@@ -40,12 +41,13 @@ export async function run(argv) {
   registerSuperGrokOAuthProvider();
 
   const args = parseCliArgs(argv);
-
   if (args.help) {
     showHelp();
     return 0;
   }
 
+  const config = loadConfig(cwd);
+  installNetworkEnvironment(config.network);
   if (args.command?.name === "login") {
     try {
       return await runLoginCommand({
@@ -67,8 +69,6 @@ export async function run(argv) {
   const stateRoot = join(homedir(), ".march");
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
 
-  // Load config (CLI args override config file values)
-  const config = loadConfig(cwd);
   const provider = args.provider ?? config.provider ?? null;
   const serviceTier = config.serviceTier ?? null;
   const model = args.model ?? config.model ?? null;

package/src/network/environment.mjs

@@ -0,0 +1,131 @@
+import { readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import tls from "node:tls";
+import { EnvHttpProxyAgent, setGlobalDispatcher } from "undici";
+
+export function installNetworkEnvironment(network = {}) {
+  const proxy = resolveProxySettings(network);
+  installProxyDispatcher(proxy);
+  const ca = installDefaultCertificates(network.ca ?? "system");
+  return { proxy, ca };
+}
+
+export function resolveProxySettings(network = {}, { env = process.env, platform = process.platform } = {}) {
+  const proxyMode = network.proxy ?? "system";
+  const explicitNoProxy = formatNoProxy(network.noProxy);
+
+  if (proxyMode === false || proxyMode === "none" || proxyMode === "direct") {
+    return { mode: "direct", httpProxy: null, httpsProxy: null, noProxy: explicitNoProxy ?? env.NO_PROXY ?? env.no_proxy ?? null };
+  }
+
+  if (typeof proxyMode === "string" && proxyMode.trim() && proxyMode !== "system") {
+    const proxy = normalizeProxyUrl(proxyMode.trim());
+    return { mode: "config", httpProxy: proxy, httpsProxy: proxy, noProxy: explicitNoProxy ?? env.NO_PROXY ?? env.no_proxy ?? null };
+  }
+
+  const envProxy = proxyFromEnv(env, explicitNoProxy);
+  if (envProxy.httpProxy || envProxy.httpsProxy) return { mode: "env", ...envProxy };
+
+  const systemProxy = platform === "win32" ? detectWindowsProxy() : null;
+  if (systemProxy?.httpProxy || systemProxy?.httpsProxy) {
+    return {
+      mode: "system",
+      httpProxy: systemProxy.httpProxy,
+      httpsProxy: systemProxy.httpsProxy,
+      noProxy: explicitNoProxy ?? systemProxy.noProxy ?? null,
+    };
+  }
+
+  return { mode: "direct", httpProxy: null, httpsProxy: null, noProxy: explicitNoProxy ?? null };
+}
+
+function installProxyDispatcher(proxy) {
+  setGlobalDispatcher(new EnvHttpProxyAgent({
+    httpProxy: proxy.httpProxy ?? "",
+    httpsProxy: proxy.httpsProxy ?? "",
+    noProxy: proxy.noProxy ?? "",
+    bodyTimeout: 0,
+    headersTimeout: 0,
+  }));
+}
+
+export function installDefaultCertificates(caConfig = "system") {
+  const entries = Array.isArray(caConfig) ? caConfig : [caConfig];
+  const wantsSystem = entries.includes("system");
+  const pemPaths = entries.filter((entry) => typeof entry === "string" && entry && entry !== "system");
+
+  if (!wantsSystem && pemPaths.length === 0) return { mode: "default", system: false, extraFiles: [] };
+  if (typeof tls.setDefaultCACertificates !== "function" || typeof tls.getCACertificates !== "function") {
+    return { mode: "unsupported", system: false, extraFiles: [] };
+  }
+
+  const certificates = [
+    ...tls.getCACertificates("default"),
+    ...(wantsSystem ? tls.getCACertificates("system") : []),
+    ...pemPaths.map((path) => readFileSync(path, "utf8")),
+  ];
+  tls.setDefaultCACertificates([...new Set(certificates)]);
+  return { mode: "installed", system: wantsSystem, extraFiles: pemPaths };
+}
+
+function proxyFromEnv(env, explicitNoProxy) {
+  const httpsProxy = env.HTTPS_PROXY ?? env.https_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? null;
+  const httpProxy = env.HTTP_PROXY ?? env.http_proxy ?? env.ALL_PROXY ?? env.all_proxy ?? null;
+  const normalizedHttp = httpProxy ? normalizeProxyUrl(httpProxy) : null;
+  return {
+    httpProxy: normalizedHttp,
+    httpsProxy: httpsProxy ? normalizeProxyUrl(httpsProxy) : normalizedHttp,
+    noProxy: explicitNoProxy ?? env.NO_PROXY ?? env.no_proxy ?? null,
+  };
+}
+
+function detectWindowsProxy() {
+  try {
+    const output = execFileSync("reg", ["query", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"], { encoding: "utf8", windowsHide: true });
+    const values = parseRegQuery(output);
+    if (values.ProxyEnable !== "0x1") return null;
+    return parseWindowsProxyServer(values.ProxyServer, values.ProxyOverride);
+  } catch {
+    return null;
+  }
+}
+
+function parseRegQuery(output) {
+  const values = {};
+  for (const line of output.split(/\r?\n/)) {
+    const match = line.trim().match(/^(\S+)\s+REG_\S+\s+(.+)$/);
+    if (match) values[match[1]] = match[2].trim();
+  }
+  return values;
+}
+
+function parseWindowsProxyServer(proxyServer, proxyOverride) {
+  if (!proxyServer) return null;
+  const entries = Object.fromEntries(proxyServer.split(";").map((part) => part.split("=")).filter((part) => part.length === 2));
+  const fallback = proxyServer.includes("=") ? null : proxyServer;
+  return {
+    httpProxy: normalizeProxyUrl(entries.http ?? fallback),
+    httpsProxy: normalizeProxyUrl(entries.https ?? entries.http ?? fallback),
+    noProxy: formatWindowsProxyOverride(proxyOverride),
+  };
+}
+
+function normalizeProxyUrl(value) {
+  if (!value) return null;
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(value) ? value : `http://${value}`;
+}
+
+function formatNoProxy(value) {
+  if (Array.isArray(value)) return value.join(",");
+  if (typeof value === "string") return value;
+  return null;
+}
+
+function formatWindowsProxyOverride(value) {
+  if (!value) return null;
+  return value
+    .split(";")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry && entry !== "<local>")
+    .join(",") || null;
+}