@xiaoso/dsh-tool-plus 0.1.0-beta.3 → 0.1.0-beta.4

package/lib/proxy-pM_NIv-H.mjs

@@ -0,0 +1,190 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { n as StreamTimeoutError, r as ValidationError, v as AbortError } from "./error-Dd8DIqs-.mjs";
+import * as tls from "node:tls";
+import * as net from "node:net";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/proxy.ts
+/**
+* Checks if a host is local or cloud metadata, which should always bypass the proxy
+* (e.g. localhost, 127/8, ::1, 169.254.169.254, metadata.google.internal).
+*/
+function isLocalOrMetadataHost(host) {
+	const lowerHost = host.toLowerCase();
+	if (lowerHost === "localhost" || lowerHost.endsWith(".localhost") || lowerHost === "metadata.google.internal") return true;
+	const ip = lowerHost.replace(/^\[|\]$/g, "");
+	const v4 = ip.match(/^(\d{1,3})\.(\d{1,3})\.\d{1,3}\.\d{1,3}$/);
+	if (v4) {
+		const a = Number(v4[1]);
+		const b = Number(v4[2]);
+		if (a === 127 || a === 10 || a === 0) return true;
+		if (a === 169 && b === 254) return true;
+		if (a === 192 && b === 168) return true;
+		if (a === 172 && b >= 16 && b <= 31) return true;
+		return false;
+	}
+	if (ip === "::1" || ip === "::") return true;
+	if (/^fe[89ab][0-9a-f]:/.test(ip)) return true;
+	if (/^f[cd][0-9a-f]{2}:/.test(ip)) return true;
+	return false;
+}
+/**
+* Check if the url should bypass the proxy due to hard-coded localhost/metadata checks
+* or custom NO_PROXY/no_proxy environment variables rules.
+*/
+function shouldBypassProxy(urlObj) {
+	if (isLocalOrMetadataHost(urlObj.hostname)) return true;
+	const noProxyVal = Bun.env.NO_PROXY || Bun.env.no_proxy;
+	if (!noProxyVal) return false;
+	const rules = noProxyVal.split(/[,\s]+/).map((r) => r.trim()).filter(Boolean);
+	const targetHost = urlObj.hostname.toLowerCase();
+	const targetPort = urlObj.port || (urlObj.protocol === "https:" || urlObj.protocol === "wss:" ? "443" : "80");
+	for (const rule of rules) {
+		if (rule === "*") return true;
+		let ruleHost = rule.toLowerCase();
+		let rulePort;
+		if (ruleHost.includes("]:")) {
+			const lastColon = ruleHost.lastIndexOf(":");
+			rulePort = ruleHost.slice(lastColon + 1);
+			ruleHost = ruleHost.slice(0, lastColon);
+		} else if (!ruleHost.includes("]") && ruleHost.includes(":")) {
+			const lastColon = ruleHost.lastIndexOf(":");
+			rulePort = ruleHost.slice(lastColon + 1);
+			ruleHost = ruleHost.slice(0, lastColon);
+		}
+		ruleHost = ruleHost.replace(/^\[|\]$/g, "");
+		if (rulePort && rulePort !== targetPort) continue;
+		if (ruleHost.startsWith(".")) {
+			const suffix = ruleHost;
+			if (targetHost === ruleHost.slice(1) || targetHost.endsWith(suffix)) return true;
+		} else if (targetHost === ruleHost || targetHost.endsWith(`.${ruleHost}`)) return true;
+	}
+	return false;
+}
+const proxyCache = /* @__PURE__ */ new Map();
+/**
+* Normalizes provider id (e.g. github-copilot -> PI_PROXY_GITHUB_COPILOT) and looks it up.
+* If not found, falls back to PI_PROXY. Results are memoized because env values are static
+* for the lifetime of the process and this function is called for every outgoing request.
+*/
+function getProxyForProvider(provider) {
+	if (proxyCache.has(provider)) return proxyCache.get(provider);
+	const envKey = `PI_PROXY_${provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+	const value = Bun.env[envKey] || Bun.env.PI_PROXY;
+	proxyCache.set(provider, value);
+	return value;
+}
+/** Resolves provider-specific and standard proxy variables for a target URL, honoring NO_PROXY. */
+function getProxyForUrl(provider, url) {
+	if (shouldBypassProxy(url)) return void 0;
+	const protocolProxy = url.protocol === "https:" || url.protocol === "wss:" ? Bun.env.HTTPS_PROXY || Bun.env.https_proxy : Bun.env.HTTP_PROXY || Bun.env.http_proxy;
+	return getProxyForProvider(provider) || protocolProxy || Bun.env.ALL_PROXY || Bun.env.all_proxy || void 0;
+}
+/**
+* Tunnel a socket connection through an HTTP CONNECT proxy.
+* This is used specifically to wrap Node's `http2.connect(baseUrl, { createConnection })` for Cursor.
+*/
+async function connectProxiedSocket(proxyUrlStr, targetUrlStr, options) {
+	if (options?.signal?.aborted) throw new AbortError("Proxy tunnel aborted");
+	const proxyUrl = new URL(proxyUrlStr);
+	const targetUrl = new URL(targetUrlStr);
+	const useProxySsl = proxyUrl.protocol === "https:";
+	const proxyPort = proxyUrl.port ? parseInt(proxyUrl.port, 10) : useProxySsl ? 443 : 80;
+	const proxyHost = proxyUrl.hostname;
+	const targetPort = targetUrl.port ? parseInt(targetUrl.port, 10) : 443;
+	const targetHost = targetUrl.hostname;
+	const { promise, resolve, reject } = Promise.withResolvers();
+	const readyEvent = useProxySsl ? "secureConnect" : "connect";
+	let rawSocket;
+	let tunnelSocket;
+	let timeout;
+	let responseData = "";
+	let settled = false;
+	const cleanup = () => {
+		if (timeout) {
+			clearTimeout(timeout);
+			timeout = void 0;
+		}
+		options?.signal?.removeEventListener("abort", onAbort);
+		rawSocket?.off("error", onRawError);
+		rawSocket?.off(readyEvent, onProxyReady);
+		rawSocket?.off("data", onProxyData);
+		tunnelSocket?.off("secureConnect", onTunnelReady);
+		tunnelSocket?.off("error", onTunnelError);
+	};
+	const destroyInProgress = () => {
+		tunnelSocket?.destroy();
+		rawSocket?.destroy();
+	};
+	const rejectOnce = (error) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		destroyInProgress();
+		reject(error);
+	};
+	const resolveOnce = (socket) => {
+		if (settled) return;
+		settled = true;
+		cleanup();
+		resolve(socket);
+	};
+	const onAbort = () => rejectOnce(new AbortError("Proxy tunnel aborted"));
+	const onRawError = (error) => rejectOnce(error);
+	const onTunnelError = (error) => rejectOnce(error);
+	const onTunnelReady = () => {
+		if (!tunnelSocket) return;
+		resolveOnce(tunnelSocket);
+	};
+	const onProxyData = (chunk) => {
+		if (!rawSocket) return;
+		responseData += chunk.toString("binary");
+		if (!responseData.includes("\r\n\r\n")) return;
+		rawSocket.off("data", onProxyData);
+		rawSocket.off("error", onRawError);
+		const firstLine = responseData.split("\r\n")[0];
+		if (!firstLine.includes(" 200 ")) {
+			rejectOnce(new ValidationError(`Proxy tunnel failed: ${firstLine}`));
+			return;
+		}
+		const tlsOptions = options?.tls;
+		tunnelSocket = tls.connect({
+			...tlsOptions,
+			socket: rawSocket,
+			servername: tlsOptions?.servername ?? targetHost,
+			ALPNProtocols: tlsOptions?.ALPNProtocols ?? ["h2"]
+		});
+		tunnelSocket.once("secureConnect", onTunnelReady);
+		tunnelSocket.once("error", onTunnelError);
+	};
+	const onProxyReady = () => {
+		if (!rawSocket) return;
+		let connectReq = `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r\nHost: ${targetHost}:${targetPort}\r\n`;
+		if (proxyUrl.username || proxyUrl.password) {
+			const creds = Buffer.from(`${decodeURIComponent(proxyUrl.username)}:${decodeURIComponent(proxyUrl.password)}`).toString("base64");
+			connectReq += `Proxy-Authorization: Basic ${creds}\r\n`;
+		}
+		connectReq += "\r\n";
+		rawSocket.write(connectReq);
+		rawSocket.on("data", onProxyData);
+	};
+	options?.signal?.addEventListener("abort", onAbort, { once: true });
+	if (options?.timeoutMs !== void 0 && Number.isFinite(options.timeoutMs) && options.timeoutMs > 0) {
+		const timeoutMs = Math.trunc(options.timeoutMs);
+		timeout = setTimeout(() => {
+			rejectOnce(new StreamTimeoutError(`Proxy tunnel timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		timeout.unref?.();
+	}
+	rawSocket = useProxySsl ? tls.connect({
+		host: proxyHost,
+		port: proxyPort
+	}) : net.connect({
+		host: proxyHost,
+		port: proxyPort
+	});
+	rawSocket.once("error", onRawError);
+	rawSocket.once(readyEvent, onProxyReady);
+	return promise;
+}
+//#endregion
+export { shouldBypassProxy as a, isLocalOrMetadataHost as i, getProxyForProvider as n, getProxyForUrl as r, connectProxiedSocket as t };

package/lib/request-debug-HJMoJncL.mjs

@@ -0,0 +1,183 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+import { n as fs_promises_shim_exports } from "./fs-promises-shim-Bx0fpxuk.mjs";
+import "node:buffer";
+//#region node_modules/.pnpm/@oh-my-pi+pi-ai@17.3.5/node_modules/@oh-my-pi/pi-ai/src/utils/request-debug.ts
+const REQUEST_DEBUG_ENV = "PI_REQ_DEBUG";
+const textEncoder = new TextEncoder();
+new TextDecoder("utf-8", { fatal: true });
+let nextSessionId = 1;
+function isRequestDebugEnvEnabled() {
+	return Bun.env[REQUEST_DEBUG_ENV] === "1";
+}
+function isRequestDebugEnabled() {
+	return isRequestDebugEnvEnabled();
+}
+async function createRequestDebugSession(payload) {
+	const { id, requestPath, responsePath, handle, overwrite } = await reserveRequestDebugFile();
+	const requestDump = {
+		id,
+		protocol: payload.protocol ?? "http",
+		method: payload.method,
+		url: payload.url
+	};
+	const headers = headersToRecord(payload.headers);
+	if (headers) requestDump.headers = headers;
+	if (payload.body !== void 0) requestDump.body = payload.body;
+	if (payload.bodyText !== void 0) requestDump.bodyText = payload.bodyText;
+	if (payload.bodyBase64 !== void 0) requestDump.bodyBase64 = payload.bodyBase64;
+	if (payload.bodyUnavailable !== void 0) requestDump.bodyUnavailable = payload.bodyUnavailable;
+	try {
+		await handle.writeFile(`${JSON.stringify(requestDump, null, 2)}\n`, "utf8");
+	} finally {
+		await handle.close();
+	}
+	return new FileRequestDebugSession(id, requestPath, responsePath, overwrite);
+}
+var FileRequestDebugSession = class {
+	id;
+	requestPath;
+	responsePath;
+	#overwriteResponseLog;
+	constructor(id, requestPath, responsePath, overwriteResponseLog) {
+		this.id = id;
+		this.requestPath = requestPath;
+		this.responsePath = responsePath;
+		this.#overwriteResponseLog = overwriteResponseLog;
+	}
+	async openResponseLog(statusLine, headers) {
+		const handle = await fs_promises_shim_exports.open(this.responsePath, this.#overwriteResponseLog ? "w" : "wx");
+		const headerBlock = formatResponseHeaderBlock(statusLine, headers);
+		await handle.write(textEncoder.encode(headerBlock));
+		return new FileRequestDebugResponseLog(handle);
+	}
+	async wrapResponse(response) {
+		const log = await this.openResponseLog(`HTTP ${response.status} ${response.statusText}`.trim(), response.headers);
+		if (!response.body) {
+			await log.close();
+			return response;
+		}
+		const reader = response.body.getReader();
+		const teed = new ReadableStream({
+			async pull(controller) {
+				try {
+					const { done, value } = await reader.read();
+					if (done) {
+						await log.close();
+						controller.close();
+						return;
+					}
+					log.write(value);
+					controller.enqueue(value);
+				} catch (error) {
+					await log.close().catch(() => void 0);
+					controller.error(error);
+				}
+			},
+			async cancel(reason) {
+				try {
+					await reader.cancel(reason);
+				} finally {
+					await log.close();
+				}
+			}
+		});
+		const wrapped = new Response(teed, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers
+		});
+		copyResponseMetadata(wrapped, response);
+		return wrapped;
+	}
+};
+var FileRequestDebugResponseLog = class {
+	#handle;
+	#pending = Promise.resolve();
+	#closed;
+	constructor(handle) {
+		this.#handle = handle;
+	}
+	write(chunk) {
+		const handle = this.#handle;
+		if (!handle) return;
+		const bytes = typeof chunk === "string" ? textEncoder.encode(chunk) : chunk.slice();
+		this.#pending = this.#pending.then(async () => {
+			await handle.write(bytes);
+		});
+	}
+	close() {
+		if (this.#closed) return this.#closed;
+		const handle = this.#handle;
+		if (!handle) return Promise.resolve();
+		this.#handle = void 0;
+		this.#closed = (async () => {
+			try {
+				await this.#pending;
+			} finally {
+				await handle.close();
+			}
+		})();
+		return this.#closed;
+	}
+};
+function copyResponseMetadata(target, source) {
+	const sourceUrl = source.url;
+	if (!sourceUrl) return;
+	try {
+		Object.defineProperty(target, "url", {
+			value: sourceUrl,
+			configurable: true
+		});
+	} catch {}
+}
+async function reserveRequestDebugFile() {
+	for (;;) {
+		const id = nextSessionId++;
+		const requestPath = `rr-session-${id}.json`;
+		try {
+			const handle = await fs_promises_shim_exports.open(requestPath, "wx");
+			return {
+				id,
+				requestPath,
+				responsePath: `rr-session-${id}.res.log`,
+				handle,
+				overwrite: false
+			};
+		} catch (error) {
+			if (isFileExistsError(error)) continue;
+			throw error;
+		}
+	}
+}
+function formatResponseHeaderBlock(statusLine, headers) {
+	const lines = [statusLine];
+	const record = headersToRecord(headers);
+	if (record) for (const name in record) {
+		const value = record[name];
+		if (Array.isArray(value)) for (const item of value) lines.push(`${name}: ${item}`);
+		else lines.push(`${name}: ${value}`);
+	}
+	return `${lines.join("\r\n")}\r\n\r\n`;
+}
+function headersToRecord(headers) {
+	if (!headers) return void 0;
+	const record = {};
+	let hasHeaders = false;
+	if (headers instanceof Headers) headers.forEach((value, key) => {
+		hasHeaders = true;
+		record[key] = value;
+	});
+	else for (const key in headers) {
+		const value = headers[key];
+		if (value === void 0 || value === null) continue;
+		hasHeaders = true;
+		record[key] = Array.isArray(value) ? value.map(String) : String(value);
+	}
+	return hasHeaders ? record : void 0;
+}
+function isFileExistsError(error) {
+	return typeof error === "object" && error !== null && error.code === "EEXIST";
+}
+//#endregion
+export { isRequestDebugEnabled as n, createRequestDebugSession as t };

package/lib/sanitize-text-CfcXzw5X.mjs

@@ -0,0 +1,33 @@
+import { installBunShim as __installBunShim } from "./bun-shim.mjs";
+__installBunShim();
+//#region node_modules/.pnpm/@oh-my-pi+pi-utils@17.3.5/node_modules/@oh-my-pi/pi-utils/src/sanitize-text.ts
+/**
+* Strip ANSI escape sequences, remove control characters / lone surrogates,
+* and normalize line endings.
+*
+* Bun-native implementation of the former native `sanitizeText` (see
+* `crates/pi-natives/src/text.rs::sanitize_text`). JavaScript strings are
+* already UTF-16 code-unit arrays. `toWellFormed()` handles the uncommon
+* malformed path; when it changes the input, replacement characters are
+* dropped and the normalized result goes through the well-formed sanitizer.
+*
+* Fast path: well-formed input with no controls or ANSI returns the original
+* string after the control probe.
+*/
+const ESC_CHAR = "\x1B";
+const CONTROL_RE = /[\x00-\x08\x0B-\x1F\x7F-\x9F]/g;
+const REPLACEMENT_CHAR = "�";
+function sanitizeText(text) {
+	const wellFormed = text.toWellFormed();
+	if (wellFormed !== text) return sanitizeWellFormedText(wellFormed.replaceAll(REPLACEMENT_CHAR, ""));
+	return sanitizeWellFormedText(text);
+}
+function sanitizeWellFormedText(text) {
+	CONTROL_RE.lastIndex = 0;
+	if (CONTROL_RE.exec(text) === null) return text;
+	const stripped = text.indexOf(ESC_CHAR) === -1 ? text : Bun.stripANSI(text);
+	CONTROL_RE.lastIndex = 0;
+	return stripped.replace(CONTROL_RE, "");
+}
+//#endregion
+export { sanitizeText as t };