@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
221 lines (201 loc) • 9.05 kB
text/typescript
import { execFileSync } from "node:child_process";
import { existsSync } from "node:fs";
import { join } from "node:path";
import { decodeWindowsTextBytes } from "./windows-text";
/**
* Startup-time discovery of the Windows WinINET static proxy (#1525, slice 1).
*
* Reads `HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings` once and returns a
* normalized `http://host:port` URL when a static proxy is enabled. PAC/WPAD, per-request
* resolution, ProxyOverride, live refresh, and direct fallback are deliberately out of scope:
* this is the piece an operator can audit from one log line, and everything else needs the
* transport boundary the reviewer asked for first. The bypass readers further down serve
* `ocx doctor` only; egress discovery does not consult them.
*/
const INTERNET_SETTINGS_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
export type WindowsSystemProxyResult =
| { kind: "proxy"; httpUrl?: string; httpsUrl?: string }
| { kind: "disabled" }
| { kind: "socks-only" }
| { kind: "unsupported" }
| { kind: "unreadable" };
/** Raw registry values; `null` when the value is absent or the read failed. */
export interface WindowsProxyRegistryValues {
proxyEnable: string | null;
proxyServer: string | null;
}
export type WindowsProxyRegistryReader = () => WindowsProxyRegistryValues | null;
function registryExe(): string {
const candidate = join(process.env.SystemRoot ?? "C:\\Windows", "System32", "reg.exe");
return existsSync(candidate) ? candidate : "reg.exe";
}
function queryValue(name: string): string | null {
try {
const stdout = execFileSync(registryExe(), ["query", INTERNET_SETTINGS_KEY, "/v", name], {
encoding: "buffer",
stdio: ["ignore", "pipe", "ignore"],
timeout: 2000,
maxBuffer: 64 * 1024,
windowsHide: true,
});
const text = decodeWindowsTextBytes(stdout);
// " ProxyServer REG_SZ host:port"
const line = text.split(/\r?\n/).find(row => row.trim().startsWith(name));
if (!line) return null;
const match = line.match(/REG_(?:SZ|DWORD|EXPAND_SZ)\s+(.*)$/);
return match ? match[1]!.trim() : null;
} catch {
return null;
}
}
export function readWindowsProxyRegistry(): WindowsProxyRegistryValues | null {
const proxyEnable = queryValue("ProxyEnable");
if (proxyEnable === null) return null;
return { proxyEnable, proxyServer: queryValue("ProxyServer") };
}
/**
* `ProxyServer` is either a bare `host:port` (applies to every scheme) or a semicolon list of
* `scheme=host:port` entries. Bare values apply to both HTTP and HTTPS destinations; per-scheme
* values retain their WinINET scope. A SOCKS-only value cannot be mirrored into HTTP(S)_PROXY.
*/
export function parseWindowsProxyServer(value: string): Extract<WindowsSystemProxyResult, { kind: "proxy" | "socks-only" | "disabled" }> {
const trimmed = value.trim();
if (!trimmed) return { kind: "disabled" };
if (!trimmed.includes("=")) {
const url = normalize(trimmed);
return url ? { kind: "proxy", httpUrl: url, httpsUrl: url } : { kind: "disabled" };
}
const entries = new Map<string, string>();
for (const part of trimmed.split(";")) {
const eq = part.indexOf("=");
if (eq <= 0) continue;
entries.set(part.slice(0, eq).trim().toLowerCase(), part.slice(eq + 1).trim());
}
const httpUrl = normalize(entries.get("http") ?? "");
const httpsUrl = normalize(entries.get("https") ?? "");
if (httpUrl || httpsUrl) return { kind: "proxy", ...(httpUrl && { httpUrl }), ...(httpsUrl && { httpsUrl }) };
if (entries.has("socks")) return { kind: "socks-only" };
return { kind: "disabled" };
}
function normalize(hostPort: string): string | undefined {
if (!hostPort) return undefined;
const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(hostPort) ? hostPort : `http://${hostPort}`;
try {
const url = new URL(withScheme);
if (!url.hostname || (url.protocol !== "http:" && url.protocol !== "https:")) return undefined;
// Keep userinfo: a credentialed proxy is valid in HTTP_PROXY. Only the log strips it.
const auth = url.username ? `${url.username}${url.password ? `:${url.password}` : ""}@` : "";
return `${url.protocol}//${auth}${url.host}`;
} catch {
return undefined;
}
}
export function readWindowsSystemProxy(
reader: WindowsProxyRegistryReader = readWindowsProxyRegistry,
platform: NodeJS.Platform = process.platform,
): WindowsSystemProxyResult {
if (platform !== "win32") return { kind: "unsupported" };
const values = reader();
if (!values) return { kind: "unreadable" };
// REG_DWORD prints as 0x1 / 0x0.
const enabled = /^(0x)?0*1$/i.test((values.proxyEnable ?? "").trim());
if (!enabled) return { kind: "disabled" };
if (!values.proxyServer) return { kind: "disabled" };
return parseWindowsProxyServer(values.proxyServer);
}
/**
* The two values that decide whether a host skips the static proxy: `ProxyOverride` (the bypass
* list) and `AutoConfigURL` (a PAC script, which takes over the decision entirely), plus the
* "Automatically detect settings" (WPAD) flag, which can also pick a proxy per request. Read on
* demand by diagnostics only; startup discovery above still ignores all three.
*/
export interface WindowsProxyBypassValues {
proxyOverride: string | null;
autoConfigUrl: string | null;
/** `null` when the connection-settings blob could not be read: detection may be on. */
autoDetect: boolean | null;
}
/** Output lines of `reg query <key>`, or `null` when the key could not be read at all. */
export type WindowsRegistryKeyLister = (key: string) => string | null;
function listRegistryKey(key: string): string | null {
try {
const stdout = execFileSync(registryExe(), ["query", key], {
encoding: "buffer",
stdio: ["ignore", "pipe", "ignore"],
timeout: 2000,
maxBuffer: 256 * 1024,
windowsHide: true,
});
return decodeWindowsTextBytes(stdout);
} catch {
return null;
}
}
function registryValue(listing: string, name: string): string | null {
for (const row of listing.split(/\r?\n/)) {
// " Name REG_TYPE data" (data is absent for an empty string)
const match = row.match(/^ {4}(\S.*?) {4}(REG_[A-Z_]+)(?: {4}(.*))?$/);
if (match && match[1]!.toLowerCase() === name.toLowerCase()) return (match[3] ?? "").trim();
}
return null;
}
/**
* WinINET `DefaultConnectionSettings` stores its flags in the ninth byte; 0x08 is
* "Automatically detect settings". Anything unparseable returns `null` (unknown), never `false`.
*/
export function parseWindowsAutoDetect(hex: string | null): boolean | null {
if (!hex || !/^[0-9a-f]{18,}$/i.test(hex)) return null;
return (Number.parseInt(hex.slice(16, 18), 16) & 0x08) !== 0;
}
/**
* Reads the bypass values from one listing of the Internet Settings key, so an absent value
* (`null`) is distinguishable from a failed read (the whole result is `null`).
*/
export function readWindowsProxyBypassRegistry(
list: WindowsRegistryKeyLister = listRegistryKey,
): WindowsProxyBypassValues | null {
const settings = list(INTERNET_SETTINGS_KEY);
if (settings === null) return null;
const connections = list(`${INTERNET_SETTINGS_KEY}\\Connections`);
return {
proxyOverride: registryValue(settings, "ProxyOverride"),
autoConfigUrl: registryValue(settings, "AutoConfigURL") || null,
autoDetect: connections === null ? null : parseWindowsAutoDetect(registryValue(connections, "DefaultConnectionSettings")),
};
}
/**
* Whether a WinINET `ProxyOverride` list exempts an HTTPS `host` (port 443). Entries are
* semicolon separated, case-insensitive, and may use `*` wildcards, a leading `.` for
* subdomains, an optional `scheme://` prefix and an optional `:port`. `<local>` matches only
* dotless names, so it never exempts a public API host.
*/
export function windowsProxyOverrideBypasses(proxyOverride: string | null, host: string): boolean {
if (!proxyOverride) return false;
const target = host.toLowerCase();
for (const raw of proxyOverride.split(";")) {
let entry = raw.trim().toLowerCase();
if (!entry) continue;
if (entry === "<local>") {
if (!target.includes(".")) return true;
continue;
}
const scheme = entry.match(/^([a-z][a-z0-9+.-]*):\/\//);
if (scheme) {
if (scheme[1] !== "https") continue;
entry = entry.slice(scheme[0].length);
}
const port = entry.match(/:(\d+)$/);
if (port) {
if (port[1] !== "443") continue;
entry = entry.slice(0, -port[0].length);
}
if (entry.startsWith(".")) entry = `*${entry}`;
const pattern = new RegExp(`^${entry.split("*").map(part => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
if (pattern.test(target)) return true;
}
return false;
}
/** Log-safe form: origin only, so a credentialed value can never reach the console. */
export function describeProxyForLog(url: string): string {
try { return new URL(url).origin; } catch { return "<unparseable>"; }
}