@oh-my-pi/pi-utils 18.11.3 → 18.12.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [18.12.0] - 2026-10-17
+
+### Added
+
+- Added `sanitizeTextDeep()`, which applies `sanitizeText()` to every string in a JSON-shaped value without mutating it ([#15963](https://github.com/can1357/oh-my-pi/issues/15963))
+
+### Fixed
+
+- Fixed Windows archive extraction overwriting existing files or following existing symlinks when copying a symlink entry without symlink privileges ([#15931](https://github.com/can1357/oh-my-pi/pull/15931) by [@jchanghong023](https://github.com/jchanghong023)).
+
 ## [18.11.3] - 2026-10-16
 
 ### Fixed

package/dist/types/sanitize-text.d.ts

@@ -12,6 +12,17 @@
  * string after the control probe.
  */
 export declare function sanitizeText(text: string): string;
+/**
+ * Apply {@link sanitizeText} to every string value inside a JSON-shaped value.
+ * Only plain objects and arrays are walked; class instances, typed arrays, and
+ * cyclic back-references pass through untouched. Object keys are kept as-is.
+ *
+ * Returns the input reference when nothing changed, so reference-keyed caches
+ * stay warm; changed containers are copied and the input is never mutated.
+ * The iterative walk also handles arbitrarily deep tool-result `details`
+ * without exhausting the TUI's call stack.
+ */
+export declare function sanitizeTextDeep(value: unknown): unknown;
 /**
  * Escape the three XML-significant characters (`&`, `<`, `>`) in text destined
  * for an XML/markup element body. Allocation-conscious: returns the input

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.11.3",
+	"version": "18.12.1",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"cli",
@@ -57,7 +57,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.11.3"
+		"@oh-my-pi/pi-natives": "18.12.1"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/ar/open.ts

@@ -234,7 +234,8 @@ export async function extractArchive(
 				// privilege; skip the entry so the rest still extracts.
 				const extracted = await archive.readFile(link.path).catch(() => undefined);
 				if (!extracted) continue;
-				await Bun.write(outputPath, extracted.bytes);
+				// Keep symlink creation's exclusive destination semantics.
+				await fs.writeFile(outputPath, extracted.bytes, { flag: "wx" });
 				const permissions = (extracted.mode ?? 0) & 0o777;
 				if (permissions) await fs.chmod(outputPath, permissions);
 			}

package/src/fetch-retry.ts

@@ -416,7 +416,11 @@ function wrapNetworkError(error: unknown): Error {
 			return new Error("Request was aborted");
 		}
 		if (error.message === "fetch failed" && error.cause instanceof Error) {
-			return new Error(`Network error: ${error.cause.message}`);
+			// Keep the original rejection as `cause`: undici nests the errno under
+			// `fetch failed` (often through an AggregateError), and
+			// classifyNetworkCause (packages/ai/src/error/network-cause.ts) walks
+			// `cause`/`errors` off this error. Flattening to text alone loses it.
+			return new Error(`Network error: ${error.cause.message}`, { cause: error });
 		}
 		return error;
 	}

package/src/sanitize-text.ts

@@ -12,6 +12,8 @@
  * string after the control probe.
  */
 
+import { isRecord } from "./type-guards";
+
 const ESC_CHAR = "\x1b";
 
 // Well-formed strings only need control/ANSI detection: C0 (excl. \t \n),
@@ -37,6 +39,74 @@ function sanitizeWellFormedText(text: string): string {
 	return stripped.replace(CONTROL_RE, "");
 }
 
+/**
+ * Apply {@link sanitizeText} to every string value inside a JSON-shaped value.
+ * Only plain objects and arrays are walked; class instances, typed arrays, and
+ * cyclic back-references pass through untouched. Object keys are kept as-is.
+ *
+ * Returns the input reference when nothing changed, so reference-keyed caches
+ * stay warm; changed containers are copied and the input is never mutated.
+ * The iterative walk also handles arbitrarily deep tool-result `details`
+ * without exhausting the TUI's call stack.
+ */
+export function sanitizeTextDeep(value: unknown): unknown {
+	if (typeof value === "string") return sanitizeText(value);
+	const root = sanitizerFrame(value);
+	if (!root) return value;
+	const stack: SanitizerFrame[] = [root];
+	const ancestors = new Set<object>([root.value]);
+	while (true) {
+		const frame = stack[stack.length - 1]!;
+		const length = frame.kind === "array" ? frame.value.length : frame.keys.length;
+		if (frame.index === length) {
+			const clean = frame.copy ?? frame.value;
+			ancestors.delete(frame.value);
+			stack.pop();
+			if (stack.length === 0) return clean;
+			acceptSanitizedValue(stack[stack.length - 1]!, clean);
+			continue;
+		}
+		const child = frame.kind === "array" ? frame.value[frame.index++] : frame.value[frame.keys[frame.index++]!];
+		if (typeof child === "string") {
+			acceptSanitizedValue(frame, sanitizeText(child));
+			continue;
+		}
+		if (child === null || typeof child !== "object" || ancestors.has(child)) continue;
+		const next = sanitizerFrame(child);
+		if (!next) continue;
+		ancestors.add(child);
+		stack.push(next);
+	}
+}
+
+type SanitizerFrame =
+	| { kind: "array"; value: unknown[]; index: number; copy?: unknown[] }
+	| { kind: "record"; value: Record<string, unknown>; keys: string[]; index: number; copy?: Record<string, unknown> };
+
+function sanitizerFrame(value: unknown): SanitizerFrame | undefined {
+	if (Array.isArray(value)) return { kind: "array", value, index: 0 };
+	if (!isRecord(value)) return undefined;
+	const proto: unknown = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return undefined;
+	return { kind: "record", value, keys: Object.keys(value), index: 0 };
+}
+
+function acceptSanitizedValue(frame: SanitizerFrame, clean: unknown): void {
+	if (frame.kind === "array") {
+		const index = frame.index - 1;
+		if (clean !== frame.value[index]) (frame.copy ??= frame.value.slice())[index] = clean;
+		return;
+	}
+	const key = frame.keys[frame.index - 1]!;
+	if (clean === frame.value[key]) return;
+	const copy = (frame.copy ??= { ...frame.value });
+	if (key === "__proto__") {
+		Object.defineProperty(copy, key, { value: clean, writable: true, enumerable: true, configurable: true });
+	} else {
+		copy[key] = clean;
+	}
+}
+
 /**
  * Escape the three XML-significant characters (`&`, `<`, `>`) in text destined
  * for an XML/markup element body. Allocation-conscious: returns the input