@xiaoso/dsh-tool-plus 0.1.16 → 0.1.17-beta.0

package/lib/provider-response-SqKSkkUc.mjs

@@ -1,22 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/provider-response.ts
-function normalizeProviderResponse(response, requestId, metadata) {
-	const headers = {};
-	response.headers.forEach((value, key) => {
-		headers[key.toLowerCase()] = value;
-	});
-	const providerResponse = {
-		status: response.status,
-		headers
-	};
-	if (requestId !== void 0) providerResponse.requestId = requestId;
-	if (metadata !== void 0) providerResponse.metadata = metadata;
-	return providerResponse;
-}
-async function notifyProviderResponse(options, response, model, requestId, metadata) {
-	if (!options?.onResponse) return;
-	await options.onResponse(normalizeProviderResponse(response, requestId, metadata), model);
-}
-//#endregion
-export { notifyProviderResponse as t };

package/lib/proxy-DxvCQOCA.mjs

@@ -1,230 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { b as debug } from "./src-AELUUb5U.mjs";
-import { _ as AbortError, n as StreamTimeoutError, r as ValidationError } from "./error-O63pC8zg.mjs";
-import * as tls from "node:tls";
-import * as net from "node:net";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/proxy.ts
-/**
-* Host:port of a proxy URL for logging. Proxy URLs can carry basic-auth
-* credentials, so never log the raw value.
-*/
-function proxyLogTarget(proxyUrl) {
-	try {
-		return new URL(proxyUrl).host;
-	} catch {
-		return "<unparseable>";
-	}
-}
-/**
-* 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);
-	debug("provider proxy resolved", {
-		provider,
-		source: Bun.env[envKey] ? envKey : value ? "PI_PROXY" : "none",
-		proxy: value ? proxyLogTarget(value) : void 0
-	});
-	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 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();
-		debug("proxy tunnel failed", {
-			proxy: `${proxyHost}:${proxyPort}`,
-			target: `${targetHost}:${targetPort}`,
-			error: String(error),
-			code: "code" in error ? String(error.code) : void 0
-		});
-		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;
-		debug("proxy tunnel established", {
-			proxy: `${proxyHost}:${proxyPort}`,
-			target: `${targetHost}:${targetPort}`,
-			peer: `${rawSocket?.remoteAddress ?? "?"}:${rawSocket?.remotePort ?? "?"}`,
-			localPort: rawSocket?.localPort,
-			alpn: tunnelSocket.alpnProtocol,
-			authorized: tunnelSocket.authorized
-		});
-		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];
-		debug("proxy tunnel CONNECT reply", {
-			proxy: `${proxyHost}:${proxyPort}`,
-			target: `${targetHost}:${targetPort}`,
-			reply: firstLine
-		});
-		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);
-		debug("proxy tunnel CONNECT sent", {
-			proxy: `${proxyHost}:${proxyPort}`,
-			target: `${targetHost}:${targetPort}`,
-			peer: `${rawSocket.remoteAddress ?? "?"}:${rawSocket.remotePort ?? "?"}`
-		});
-	};
-	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?.();
-	}
-	const 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 { getProxyForUrl as n, isLocalOrMetadataHost as r, connectProxiedSocket as t };

package/lib/request-debug-BwPOqN_j.mjs

@@ -1,183 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-import { n as fs_promises_shim_exports } from "./fs-promises-shim-B2YFWkcd.mjs";
-import "node:buffer";
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/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-BCf5KmCf.mjs

@@ -1,33 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-utils@18.1.17/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 };

package/lib/sse-debug-B-tkLCPW.mjs

@@ -1,11 +0,0 @@
-import { installBunShim as __installBunShim } from "./bun-shim.mjs";
-__installBunShim();
-//#region node_modules/.pnpm/@oh-my-pi+pi-ai@18.1.17/node_modules/@oh-my-pi/pi-ai/src/utils/sse-debug.ts
-function notifyRawSseEvent(observer, event) {
-	if (!observer) return;
-	try {
-		observer(event);
-	} catch {}
-}
-//#endregion
-export { notifyRawSseEvent as t };