@karoc/dsh-proxy 0.1.0

package/lib/index.js

@@ -0,0 +1,960 @@
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { createServer, request } from "node:http";
+import { connect } from "node:net";
+import { connect as connect$1 } from "node:tls";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+//#region src/proxy-core.ts
+/**
+* dsh-proxy core: a loopback forward proxy with per-host routing, ported
+* verbatim from dsh-desktop's scripts/proxy.mjs (behavior preserved).
+*
+* The proxy is the SINGLE egress point for the host's outbound traffic:
+* dsh model fetch (undici), web search, npm install/update, git, child CLIs.
+* The host points everything at it via HTTP(S)_PROXY=http://127.0.0.1:<port>
+* + NODE_USE_ENV_PROXY=1 + NO_PROXY=127.0.0.1,localhost,::1.
+*
+* Routing is per-host and read LIVE from <DSH_HOME>/proxy.json on every
+* request, so toggling a host in the settings page takes effect immediately
+* (no dsh restart needed):
+*   {
+*     "upstream": { "enabled": bool, "protocol": "http"|"https"|"socks5",
+*                   "host": "", "port": 0, "username": "", "password": "" },
+*     "proxiedHosts": ["api.deepseek.com", ...],   // hosts that go upstream
+*     "knownHosts":  ["api.deepseek.com", ...]     // observed, for the UI
+*   }
+* Default: everything connects DIRECT. Only hosts in `proxiedHosts` (with
+* `upstream.enabled`) are forwarded to the upstream proxy, optionally with
+* Basic auth (Proxy-Authorization).
+*
+* Hard safety rules:
+*   * loopback targets are ALWAYS direct (never sent to an upstream proxy);
+*   * an upstream pointing back at this very proxy is treated as disabled
+*     (self-loop guard);
+*   * the proxy itself uses raw net/http (never undici's env-proxy), so it can
+*     never route its own outbound connections back through itself.
+*/
+const LOOPBACK = /^(127\.0\.0\.1|localhost|::1|0\.0\.0\.0)$/i;
+/** Upstream proxy protocol, defaulting to http (legacy configs have no field). */
+function upstreamProtocol(cfg) {
+	return String(cfg?.upstream?.protocol || "http").toLowerCase();
+}
+/** Read exactly n bytes from a socket (SOCKS5 fixed-size frames). */
+function readExactly(socket, n, timeoutMs = 1e4) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		let buf = Buffer.alloc(0);
+		const timer = setTimeout(() => {
+			cleanup();
+			rejectPromise(/* @__PURE__ */ new Error("upstream handshake timeout"));
+		}, timeoutMs);
+		const onData = (chunk) => {
+			buf = Buffer.concat([buf, chunk]);
+			if (buf.length >= n) {
+				cleanup();
+				resolvePromise(buf);
+			}
+		};
+		const onErr = (e) => {
+			cleanup();
+			rejectPromise(e);
+		};
+		const cleanup = () => {
+			clearTimeout(timer);
+			socket.removeListener("data", onData);
+			socket.removeListener("error", onErr);
+		};
+		socket.on("data", onData);
+		socket.on("error", onErr);
+	});
+}
+/** Read until a byte terminator (HTTP CONNECT response headers). */
+function readUntil(socket, terminator, timeoutMs = 1e4) {
+	return new Promise((resolvePromise, rejectPromise) => {
+		let buf = Buffer.alloc(0);
+		const timer = setTimeout(() => {
+			cleanup();
+			rejectPromise(/* @__PURE__ */ new Error("upstream handshake timeout"));
+		}, timeoutMs);
+		const onData = (chunk) => {
+			buf = Buffer.concat([buf, chunk]);
+			const idx = buf.indexOf(terminator);
+			if (idx >= 0) {
+				cleanup();
+				resolvePromise({
+					head: buf.slice(0, idx + terminator.length).toString(),
+					rest: buf.slice(idx + terminator.length)
+				});
+			}
+		};
+		const onErr = (e) => {
+			cleanup();
+			rejectPromise(e);
+		};
+		const cleanup = () => {
+			clearTimeout(timer);
+			socket.removeListener("data", onData);
+			socket.removeListener("error", onErr);
+		};
+		socket.on("data", onData);
+		socket.on("error", onErr);
+	});
+}
+/**
+* SOCKS5 handshake against the upstream: greeting (with optional RFC1929
+* user/pass auth), then CONNECT to the target. Resolves once the tunnel is
+* ready (BND.ADDR consumed).
+*/
+async function socks5Handshake(socket, upstream, targetHost, targetPort) {
+	const methods = Boolean(upstream.username) ? [0, 2] : [0];
+	socket.write(Buffer.from([
+		5,
+		methods.length,
+		...methods
+	]));
+	const methodResp = await readExactly(socket, 2);
+	if (methodResp[0] !== 5) throw new Error(`socks5: bad version ${methodResp[0]}`);
+	const method = methodResp[1];
+	if (method === 255) throw new Error("socks5: no acceptable auth method");
+	if (method === 2) {
+		const user = Buffer.from(upstream.username || "", "utf8");
+		const pass = Buffer.from(upstream.password || "", "utf8");
+		socket.write(Buffer.concat([
+			Buffer.from([1, user.length]),
+			user,
+			Buffer.from([pass.length]),
+			pass
+		]));
+		const authResp = await readExactly(socket, 2);
+		if (authResp[0] !== 1 || authResp[1] !== 0) throw new Error("socks5: auth failed");
+	} else if (method !== 0) throw new Error(`socks5: unsupported auth method ${method}`);
+	const isIpv4 = /^\d{1,3}(?:\.\d{1,3}){3}$/.test(targetHost);
+	let addrPart;
+	if (isIpv4) addrPart = Buffer.concat([Buffer.from([1]), ...targetHost.split(".").map((o) => Buffer.from([Number(o) & 255]))]);
+	else {
+		const name = Buffer.from(targetHost, "ascii");
+		addrPart = Buffer.concat([Buffer.from([3, name.length]), name]);
+	}
+	const portBuf = Buffer.from([targetPort >> 8 & 255, targetPort & 255]);
+	socket.write(Buffer.concat([
+		Buffer.from([
+			5,
+			1,
+			0
+		]),
+		addrPart,
+		portBuf
+	]));
+	const connResp = await readExactly(socket, 4);
+	if (connResp[0] !== 5 || connResp[1] !== 0) throw new Error(`socks5: CONNECT failed (code ${connResp[1]})`);
+	const atyp = connResp[3];
+	if (atyp === 3) await readExactly(socket, 1 + (await readExactly(socket, 1))[0] + 2);
+	else if (atyp === 1) await readExactly(socket, 6);
+	else if (atyp === 4) await readExactly(socket, 18);
+}
+/**
+* Open a tunnel THROUGH the configured upstream proxy to target:port.
+* Returns { socket, rest } where `socket` is ready to pipe and `rest` holds
+* any bytes already read past the handshake (HTTP CONNECT responses).
+* Supports http / https / socks5 upstream protocols.
+*/
+function openUpstreamTunnel(cfg, targetHost, targetPort, authHeader) {
+	const u = cfg.upstream;
+	const protocol = upstreamProtocol(cfg);
+	return new Promise((resolvePromise, rejectPromise) => {
+		let socket;
+		const fail = (e) => {
+			try {
+				socket?.destroy();
+			} catch {}
+			rejectPromise(e);
+		};
+		if (protocol === "https") socket = connect$1({
+			host: u.host,
+			port: Number(u.port),
+			servername: u.host
+		});
+		else socket = connect({
+			host: u.host,
+			port: Number(u.port)
+		});
+		socket.on("error", fail);
+		socket.on("connect", async () => {
+			try {
+				if (protocol === "socks5") {
+					await socks5Handshake(socket, u, targetHost, targetPort);
+					resolvePromise({
+						socket,
+						rest: Buffer.alloc(0)
+					});
+				} else {
+					const lines = [`CONNECT ${targetHost}:${targetPort} HTTP/1.1`, `Host: ${targetHost}:${targetPort}`];
+					if (authHeader) lines.push(`Proxy-Authorization: ${authHeader}`);
+					socket.write(lines.join("\r\n") + "\r\n\r\n");
+					const { head, rest } = await readUntil(socket, "\r\n\r\n");
+					if (!/^HTTP\/1\.[01]\s+2\d\d/.test(head)) throw new Error(`upstream CONNECT rejected: ${head.split("\r\n")[0] || "no status"}`);
+					resolvePromise({
+						socket,
+						rest
+					});
+				}
+			} catch (e) {
+				fail(e);
+			}
+		});
+	});
+}
+/** Fresh default proxy config (factory so callers never share a mutable copy). */
+function defaultProxyConfig() {
+	return {
+		upstream: {
+			enabled: false,
+			protocol: "http",
+			host: "",
+			port: 0,
+			username: "",
+			password: ""
+		},
+		proxiedHosts: [],
+		knownHosts: []
+	};
+}
+/** Read <configFile> (proxy.json), tolerant of a missing/corrupt file. */
+function readProxyConfig(configFile) {
+	try {
+		const raw = JSON.parse(readFileSync(configFile, "utf8"));
+		return {
+			...defaultProxyConfig(),
+			...raw ?? {},
+			upstream: {
+				...defaultProxyConfig().upstream,
+				...raw?.upstream ?? {}
+			}
+		};
+	} catch {
+		return defaultProxyConfig();
+	}
+}
+/**
+* Best-effort extraction of model provider hosts from a dsh settings.yaml
+* (llm-deepseek.baseURL / llm-pi-ai.providers.<n>.baseURL / any other llm-*
+* namespace). Returns [{name, host, displayName?}]: `name` is the dsh
+* namespace (or `ns/provider`), `displayName` the friendly name when known
+* (llm-pi-ai providers carry a `displayName` field; llm-deepseek is fixed to
+* "DeepSeek"). Empty when unreadable — the proxy's observed-host list still
+* populates the settings UI.
+*/
+function providerHostsFromSettings(settingsPath) {
+	const out = [];
+	let text;
+	try {
+		text = readFileSync(settingsPath, "utf8");
+	} catch {
+		return out;
+	}
+	const push = (current) => {
+		const name = current.provider ? `${current.ns}/${current.provider}` : current.ns;
+		const displayName = current.displayName || (current.ns === "llm-deepseek" ? "DeepSeek" : null);
+		for (const baseUrl of current.baseUrls) for (const candidate of String(baseUrl).split(",").map((s) => s.trim()).filter(Boolean)) try {
+			const host = new URL(candidate).hostname;
+			if (host) out.push({
+				name,
+				...displayName ? { displayName } : {},
+				host
+			});
+		} catch {}
+	};
+	let ns = null;
+	let inProviders = false;
+	let current = null;
+	const flush = () => {
+		if (current && current.baseUrls.length) push(current);
+		current = null;
+	};
+	for (const raw of text.split(/\r?\n/)) {
+		const line = raw.replace(/#.*$/, "").replace(/\s+$/, "");
+		const top = line.match(/^([A-Za-z0-9_.-]+):\s*$/);
+		if (top) {
+			flush();
+			ns = top[1];
+			inProviders = false;
+			continue;
+		}
+		if (!ns?.startsWith("llm-")) continue;
+		const two = line.match(/^ {2}([A-Za-z0-9_.-]+):\s*$/);
+		if (two) {
+			flush();
+			inProviders = two[1] === "providers";
+			current = inProviders ? null : {
+				ns,
+				provider: two[1],
+				displayName: null,
+				baseUrls: []
+			};
+			continue;
+		}
+		const four = line.match(/^ {4}([A-Za-z0-9_.-]+):\s*$/);
+		if (four && inProviders) {
+			flush();
+			current = {
+				ns,
+				provider: four[1],
+				displayName: null,
+				baseUrls: []
+			};
+			continue;
+		}
+		if (current) {
+			const dn = line.match(/^ {2,}displayName:\s*(.+)$/);
+			if (dn) {
+				current.displayName = String(dn[1]).trim().replace(/^['"]|['"]$/g, "");
+				continue;
+			}
+			const b = line.match(/^ {2,}baseURL:\s*(.+)$/);
+			if (b) {
+				current.baseUrls.push(b[1]);
+				continue;
+			}
+		} else if (!inProviders) {
+			const b = line.match(/^ {2}baseURL:\s*(.+)$/);
+			if (b) current = {
+				ns,
+				provider: null,
+				displayName: null,
+				baseUrls: [b[1]]
+			};
+		}
+	}
+	flush();
+	return out;
+}
+/**
+* Pure routing decision: should `host` go through the upstream proxy?
+* Loopback targets are ALWAYS direct; an upstream pointing back at this very
+* proxy (same loopback + same port) is treated as disabled (self-loop guard).
+*/
+function shouldProxy(cfg, host, selfPort) {
+	const h = String(host ?? "").toLowerCase();
+	if (LOOPBACK.test(h)) return false;
+	const u = cfg?.upstream;
+	const selfRef = u?.host && LOOPBACK.test(u.host.toLowerCase()) && Number(u.port) === selfPort;
+	return Boolean(u?.enabled) && !selfRef && (cfg?.proxiedHosts ?? []).includes(h);
+}
+/**
+* Start a forward proxy bound to 127.0.0.1:<random>.
+*/
+function createForwardProxy(opts) {
+	const { configFile, onHosts, log = () => {} } = opts;
+	const seenHosts = /* @__PURE__ */ new Set();
+	let notifyTimer = null;
+	const markHost = (host) => {
+		const h = String(host ?? "").trim().toLowerCase();
+		if (!h || LOOPBACK.test(h)) return;
+		if (seenHosts.has(h)) return;
+		seenHosts.add(h);
+		if (notifyTimer) clearTimeout(notifyTimer);
+		notifyTimer = setTimeout(() => onHosts?.([...seenHosts].sort()), 400);
+	};
+	const config = () => readProxyConfig(configFile);
+	const upstreamAuth = (cfg) => {
+		const u = cfg.upstream;
+		if (u?.username) return "Basic " + Buffer.from(`${u.username}:${u.password ?? ""}`).toString("base64");
+		return null;
+	};
+	/** Decide the route for one target host. */
+	const routeFor = (host, selfPort) => {
+		const cfg = config();
+		return {
+			via: shouldProxy(cfg, host, selfPort) ? "upstream" : "direct",
+			cfg
+		};
+	};
+	/** Bidirectional relay between two sockets; errors/close tear both down. */
+	const pipeTunnel = (a, b) => {
+		a.on("error", () => {
+			try {
+				b.destroy();
+			} catch {}
+		});
+		b.on("error", () => {
+			try {
+				a.destroy();
+			} catch {}
+		});
+		a.pipe(b);
+		b.pipe(a);
+		const cleanup = () => {
+			try {
+				a.destroy();
+			} catch {}
+			try {
+				b.destroy();
+			} catch {}
+		};
+		a.on("close", cleanup);
+		b.on("close", cleanup);
+	};
+	const server = createServer((req, res) => {
+		let u;
+		try {
+			u = new URL(req.url ?? "");
+		} catch {
+			res.writeHead(400, { "content-type": "text/plain" });
+			res.end("proxy: bad request-target");
+			return;
+		}
+		const host = u.hostname.toLowerCase();
+		const port = Number(u.port || (u.protocol === "https:" ? 443 : 80));
+		if (!host || !port) {
+			res.writeHead(400, { "content-type": "text/plain" });
+			res.end("proxy: missing host");
+			return;
+		}
+		markHost(host);
+		const { via, cfg } = routeFor(host, server.address()?.port);
+		const headers = { ...req.headers };
+		delete headers["proxy-connection"];
+		delete headers["connection"];
+		let useUpstream = via === "upstream";
+		if (useUpstream && upstreamProtocol(cfg) === "socks5") {
+			log(`socks5 upstream: http target ${host} falls back to direct`);
+			useUpstream = false;
+		}
+		if (useUpstream) {
+			const auth = upstreamAuth(cfg);
+			if (auth) headers["proxy-authorization"] = auth;
+			const up = request({
+				host: cfg.upstream.host,
+				port: Number(cfg.upstream.port),
+				method: req.method,
+				path: req.url ?? "",
+				headers
+			}, (upRes) => {
+				res.writeHead(upRes.statusCode ?? 502, upRes.headers);
+				upRes.pipe(res);
+			});
+			up.on("error", (e) => {
+				res.writeHead(502, { "content-type": "text/plain" });
+				res.end(`proxy: upstream error: ${e.message}`);
+			});
+			req.pipe(up);
+		} else {
+			const up = request({
+				host,
+				port,
+				method: req.method,
+				path: u.pathname + u.search,
+				headers
+			}, (upRes) => {
+				res.writeHead(upRes.statusCode ?? 502, upRes.headers);
+				upRes.pipe(res);
+			});
+			up.on("error", (e) => {
+				res.writeHead(502, { "content-type": "text/plain" });
+				res.end(`proxy: origin error: ${e.message}`);
+			});
+			req.pipe(up);
+		}
+	});
+	server.on("connect", (req, clientSocket, head) => {
+		const [hostRaw, portRaw] = String(req.url ?? "").split(":");
+		const host = (hostRaw ?? "").toLowerCase();
+		const port = Number(portRaw) || 443;
+		if (!host || !port) {
+			clientSocket.destroy();
+			return;
+		}
+		markHost(host);
+		const { via, cfg } = routeFor(host, server.address()?.port);
+		const rejectClient = (reason) => {
+			const msg = String(typeof reason === "object" && reason !== null ? reason.message ?? reason : reason).slice(0, 200).replace(/[\r\n]+/g, " ");
+			log(`connect ${host}:${port} failed: ${msg}`);
+			try {
+				clientSocket.write(`HTTP/1.1 502 Bad Gateway\r\nContent-Length: ${Buffer.byteLength(msg)}\r\n\r\n${msg}`);
+			} catch {}
+			try {
+				clientSocket.destroy();
+			} catch {}
+		};
+		if (via === "upstream") openUpstreamTunnel(cfg, host, port, upstreamAuth(cfg)).then(({ socket: tunnel, rest }) => {
+			clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+			if (head?.length) tunnel.write(head);
+			if (rest.length) clientSocket.write(rest);
+			pipeTunnel(clientSocket, tunnel);
+		}).catch(rejectClient);
+		else {
+			const origin = connect({
+				host,
+				port
+			});
+			origin.on("error", rejectClient);
+			origin.on("connect", () => {
+				clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+				if (head?.length) origin.write(head);
+				pipeTunnel(clientSocket, origin);
+			});
+		}
+	});
+	return {
+		port: new Promise((resolve) => {
+			server.listen(0, "127.0.0.1", () => resolve(server.address().port));
+		}),
+		hosts: () => [...seenHosts].sort(),
+		config,
+		/** Merge observed hosts into proxy.json's knownHosts (UI candidate list). */
+		persistKnownHosts: () => {
+			try {
+				const cfg = config();
+				const merged = [.../* @__PURE__ */ new Set([...cfg.knownHosts ?? [], ...seenHosts])].sort();
+				writeFileSync(configFile, JSON.stringify({
+					...cfg,
+					knownHosts: merged
+				}, null, 2) + "\n");
+			} catch (e) {
+				log(`proxy: persist known hosts failed: ${e.message}`);
+			}
+		},
+		close: () => {
+			if (notifyTimer) clearTimeout(notifyTimer);
+			server.close();
+		}
+	};
+}
+/**
+* Clean each host: trim, lowercase, drop a trailing comma (a historical
+* "api.xxx.com," never matches the real CONNECT target and silently breaks
+* routing — never let it back into proxy.json). Returns '' for unusable input.
+*/
+function normalizeHost(h) {
+	return String(h ?? "").trim().toLowerCase().replace(/,\s*$/, "").trim();
+}
+/**
+* Sanitize an upstream object coming from the settings page: only known
+* fields, only valid types/ports (a hostile page must not smuggle extra keys
+* into proxy.json). Ported from dsh-desktop's Rust sanitize_upstream.
+*/
+function sanitizeUpstream(v) {
+	const obj = typeof v === "object" && v !== null ? v : {};
+	const get = (k) => typeof obj[k] === "string" ? obj[k] : "";
+	const protocol = obj["protocol"] === "https" ? "https" : obj["protocol"] === "socks5" ? "socks5" : "http";
+	const rawPort = typeof obj["port"] === "number" ? obj["port"] : typeof obj["port"] === "string" ? Number(obj["port"]) : 0;
+	const port = Number.isFinite(rawPort) ? Math.max(0, Math.min(rawPort, 65535)) : 0;
+	return {
+		enabled: obj["enabled"] === true,
+		protocol,
+		host: get("host").trim(),
+		port,
+		username: get("username"),
+		password: get("password")
+	};
+}
+/**
+* Persist a proxy config atomically from the settings page. Sanitizes the
+* upstream and normalizes the proxied host list (the page never writes
+* arbitrary keys). Takes effect immediately: the running proxy re-reads
+* proxy.json on every request.
+*/
+function writeProxyConfig(configFile, upstream, proxiedHosts) {
+	const cfg = readProxyConfig(configFile);
+	const hosts = [];
+	for (const h of proxiedHosts ?? []) {
+		const t = normalizeHost(h);
+		if (t !== "") hosts.push(t);
+	}
+	const next = {
+		...cfg,
+		upstream: sanitizeUpstream(upstream),
+		proxiedHosts: hosts
+	};
+	const text = JSON.stringify(next, null, 2);
+	try {
+		mkdirSync(dirname(configFile), { recursive: true });
+	} catch {}
+	writeFileSync(configFile, text + "\n");
+	return next;
+}
+/**
+* Verify the configured upstream proxy is reachable and speaks its protocol.
+* HTTP/HTTPS: send a CONNECT probe (1.1.1.1:443); SOCKS5: handshake + CONNECT.
+* HTTPS upstreams can't be TLS-verified without a TLS crate — TCP reachability
+* is the honest signal available. Ported from dsh-desktop's Rust test_proxy.
+*/
+function testUpstreamProxy(upstream) {
+	const { host, port, protocol, username, password } = sanitizeUpstream(upstream);
+	if (host === "" || port === 0) return Promise.resolve({
+		ok: false,
+		detail: "请先填写代理主机和端口"
+	});
+	const addr = `${host}:${port}`;
+	return new Promise((resolvePromise) => {
+		const sock = connect({
+			host,
+			port
+		});
+		const timeout = setTimeout(() => {
+			try {
+				sock.destroy();
+			} catch {}
+			resolvePromise({
+				ok: false,
+				detail: `无法连接 ${addr}: timeout`
+			});
+		}, 5e3);
+		const fail = (e) => {
+			clearTimeout(timeout);
+			try {
+				sock.destroy();
+			} catch {}
+			resolvePromise({
+				ok: false,
+				detail: `无法连接 ${addr}: ${e.message}`
+			});
+		};
+		sock.on("error", fail);
+		sock.setTimeout(5e3, () => fail(/* @__PURE__ */ new Error("timeout")));
+		sock.on("connect", () => {
+			try {
+				if (protocol === "socks5") {
+					const methods = username !== "" ? [
+						5,
+						2,
+						0,
+						2
+					] : [
+						5,
+						1,
+						0
+					];
+					sock.write(Buffer.from(methods));
+					sock.once("data", (greeting) => {
+						if (greeting[0] !== 5) {
+							clearTimeout(timeout);
+							sock.destroy();
+							resolvePromise({
+								ok: false,
+								detail: `SOCKS5 版本异常 (${greeting[0]})`
+							});
+							return;
+						}
+						const handleMethod = (method) => {
+							if (method === 255) {
+								clearTimeout(timeout);
+								sock.destroy();
+								resolvePromise({
+									ok: false,
+									detail: "上游无可用认证方式"
+								});
+								return;
+							}
+							if (method === 2) {
+								const user = Buffer.from(username, "utf8");
+								const pass = Buffer.from(password, "utf8");
+								const auth = Buffer.concat([
+									Buffer.from([1, user.length]),
+									user,
+									Buffer.from([pass.length]),
+									pass
+								]);
+								sock.write(auth);
+								sock.once("data", (ar) => {
+									if (ar[0] !== 1 || ar[1] !== 0) {
+										clearTimeout(timeout);
+										sock.destroy();
+										resolvePromise({
+											ok: false,
+											detail: "SOCKS5 认证失败"
+										});
+									} else sendConnect();
+								});
+							} else if (method !== 0) {
+								clearTimeout(timeout);
+								sock.destroy();
+								resolvePromise({
+									ok: false,
+									detail: `不支持的认证方式 (${method})`
+								});
+							} else sendConnect();
+						};
+						const sendConnect = () => {
+							sock.write(Buffer.from([
+								5,
+								1,
+								0,
+								1,
+								1,
+								1,
+								1,
+								1,
+								1,
+								187
+							]));
+							sock.once("data", (cr) => {
+								if (cr[0] !== 5 || cr[1] !== 0) {
+									clearTimeout(timeout);
+									sock.destroy();
+									resolvePromise({
+										ok: false,
+										detail: `SOCKS5 CONNECT 失败 (code ${cr[1]})`
+									});
+								} else if (cr.slice(4).length >= 6) {
+									clearTimeout(timeout);
+									sock.destroy();
+									resolvePromise({
+										ok: true,
+										detail: "SOCKS5 握手成功，可转发"
+									});
+								} else sock.once("data", () => {
+									clearTimeout(timeout);
+									sock.destroy();
+									resolvePromise({
+										ok: true,
+										detail: "SOCKS5 握手成功，可转发"
+									});
+								});
+							});
+						};
+						handleMethod(greeting[1]);
+					});
+				} else if (protocol === "https") {
+					clearTimeout(timeout);
+					sock.destroy();
+					resolvePromise({
+						ok: true,
+						detail: "端口已连通（HTTPS 代理的 TLS 握手未验证）"
+					});
+				} else {
+					const target = "1.1.1.1:443";
+					let req = `CONNECT ${target} HTTP/1.1\r\nHost: ${target}\r\n`;
+					if (username !== "") req += `Proxy-Authorization: Basic ${Buffer.from(`${username}:${password}`).toString("base64")}\r\n`;
+					req += "\r\n";
+					sock.write(req);
+					let buf = "";
+					const onData = (chunk) => {
+						buf += chunk.toString();
+						if (!buf.includes("\r\n\r\n")) return;
+						sock.removeListener("data", onData);
+						const statusLine = buf.split("\r\n")[0];
+						clearTimeout(timeout);
+						sock.destroy();
+						if (/^HTTP\/1\.[01]\s+2/.test(statusLine)) resolvePromise({
+							ok: true,
+							detail: "上游代理可转发（CONNECT 2xx）"
+						});
+						else if (statusLine.includes("407")) resolvePromise({
+							ok: false,
+							detail: "上游要求认证（407）"
+						});
+						else resolvePromise({
+							ok: false,
+							detail: `上游响应异常: ${statusLine.trim()}`
+						});
+					};
+					sock.on("data", onData);
+				}
+			} catch (e) {
+				fail(e);
+			}
+		});
+	});
+}
+//#endregion
+//#region src/index.ts
+const name = "dsh-proxy";
+const inject = ["webServer"];
+/** Resolve the harness home: $DSH_HOME (blank = unset) else ~/.dsh. */
+function resolveDshHome() {
+	const env = process.env.DSH_HOME;
+	const selected = env !== void 0 && env.trim().length > 0 ? env : join(homedir(), ".dsh");
+	return resolve(selected);
+}
+/** The proxy config file (persisted, hand-editable, like dsh-desktop). */
+function proxyConfigPath(home = resolveDshHome()) {
+	return join(home, "proxy.json");
+}
+/** The dsh settings.yaml this plugin derives model-provider hosts from. */
+function settingsPath(home = resolveDshHome()) {
+	return join(home, "settings.yaml");
+}
+const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
+function sendJson(res, status, value) {
+	res.writeHead(status, JSON_HEADERS);
+	res.end(JSON.stringify(value));
+}
+/** Collect a request body (bounded — proxy configs are tiny). */
+function readBody(req) {
+	return new Promise((resolvePromise, reject) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > 65536) {
+				reject(/* @__PURE__ */ new Error("dsh-proxy: request body too large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolvePromise(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", reject);
+	});
+}
+/** Build the fresh settings view. */
+function viewOf(forwardProxy) {
+	const cfg = forwardProxy.config();
+	return {
+		ok: true,
+		port: forwardProxy.currentPort,
+		upstream: cfg.upstream,
+		proxiedHosts: cfg.proxiedHosts,
+		knownHosts: cfg.knownHosts,
+		hosts: forwardProxy.hosts(),
+		providers: providerHostsFromSettings(settingsPath())
+	};
+}
+/** Start the loopback forward proxy and re-point the process at it. */
+function startProxy(opts) {
+	const { configFile, log } = opts;
+	let currentPort = null;
+	let persistTimer = null;
+	const handle = createForwardProxy({
+		configFile,
+		onHosts: (hosts) => {
+			if (persistTimer) clearTimeout(persistTimer);
+			persistTimer = setTimeout(() => {
+				try {
+					handle.persistKnownHosts();
+				} catch {}
+			}, 2e3);
+			log(`dsh-proxy: observed hosts: ${hosts.join(", ")}`);
+		},
+		log
+	});
+	const wrapped = {
+		port: handle.port,
+		currentPort,
+		hosts: handle.hosts,
+		config: handle.config,
+		persistKnownHosts: handle.persistKnownHosts,
+		close: () => {
+			if (persistTimer) clearTimeout(persistTimer);
+			handle.close();
+		}
+	};
+	handle.port.then((port) => {
+		wrapped.currentPort = port;
+		log(`dsh-proxy: forward proxy on 127.0.0.1:${port}`);
+		process.env.NODE_USE_ENV_PROXY = "1";
+		process.env.HTTP_PROXY = `http://127.0.0.1:${port}`;
+		process.env.HTTPS_PROXY = `http://127.0.0.1:${port}`;
+		process.env.ALL_PROXY = `http://127.0.0.1:${port}`;
+		process.env.NO_PROXY = [
+			"127.0.0.1",
+			"localhost",
+			"::1",
+			process.env.NO_PROXY
+		].filter(Boolean).join(",");
+	}).catch((error) => {
+		log(`dsh-proxy: forward proxy start failed (continuing without it): ${error.message}`);
+	});
+	return wrapped;
+}
+/** Register the /proxy/api route (GET view, POST save/test/persist). */
+function registerWebApi(ctx, forwardProxy) {
+	const server = ctx.get("webServer");
+	if (server === void 0) return;
+	server.register({
+		kind: "prefix",
+		path: "/proxy/api",
+		handler: (req, res) => {
+			handle(req, res).catch((error) => {
+				if (!res.writableEnded) sendJson(res, 500, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			});
+		}
+	});
+	async function handle(req, res) {
+		const method = req.method ?? "GET";
+		if (method === "GET") {
+			sendJson(res, 200, viewOf(forwardProxy));
+			return;
+		}
+		if (method === "POST") {
+			const raw = await readBody(req);
+			let body;
+			try {
+				body = JSON.parse(raw);
+			} catch (error) {
+				sendJson(res, 400, {
+					ok: false,
+					error: `dsh-proxy: invalid JSON body: ${error.message}`
+				});
+				return;
+			}
+			switch (body.op) {
+				case "save":
+					try {
+						const cfg = writeProxyConfig(proxyConfigPath(), body.upstream, Array.isArray(body.proxiedHosts) ? body.proxiedHosts : []);
+						sendJson(res, 200, {
+							...viewOf(forwardProxy),
+							upstream: cfg.upstream,
+							proxiedHosts: cfg.proxiedHosts
+						});
+					} catch (error) {
+						sendJson(res, 400, {
+							ok: false,
+							error: `dsh-proxy: save failed: ${error.message}`
+						});
+					}
+					return;
+				case "test": {
+					const result = await testUpstreamProxy(body.upstream);
+					sendJson(res, 200, {
+						ok: result.ok,
+						detail: result.detail
+					});
+					return;
+				}
+				case "persist":
+					try {
+						forwardProxy.persistKnownHosts();
+					} catch {}
+					sendJson(res, 200, viewOf(forwardProxy));
+					return;
+				default: sendJson(res, 400, {
+					ok: false,
+					error: `dsh-proxy: unknown op ${JSON.stringify(body.op)}`
+				});
+			}
+			return;
+		}
+		sendJson(res, 405, {
+			ok: false,
+			error: `dsh-proxy: method ${method} not allowed`
+		});
+	}
+}
+/**
+* Host plugin body: start the forward proxy, point the process at it, and
+* serve /proxy/api. Disposal closes the proxy (env vars are left as-is — the
+* process owns them for its lifetime).
+*/
+function apply(ctx) {
+	const log = (line) => {
+		try {
+			ctx.logger?.info(`[dsh-proxy] ${line}`);
+		} catch {}
+	};
+	const forwardProxy = startProxy({
+		configFile: proxyConfigPath(),
+		log
+	});
+	registerWebApi(ctx, forwardProxy);
+	ctx.effect(() => () => {
+		try {
+			forwardProxy.close();
+		} catch {}
+	}, "dsh-proxy: teardown");
+}
+//#endregion
+export { apply, inject, name, proxyConfigPath, resolveDshHome, settingsPath };