@gjermundgaraba/upup 0.2.0 → 0.4.0

package/dist/grep-worker.mjs

@@ -0,0 +1,204 @@
+import { n as reason, t as openFlags } from "./io-BGJ4Yp7u.mjs";
+import path from "node:path";
+import { closeSync, fstatSync, openSync, readSync, readdirSync } from "node:fs";
+import { parentPort } from "node:worker_threads";
+// src/audit/grep-worker.ts
+var GrepError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GrepError";
+	}
+};
+const tooLarge = "grep result exceeds 256 KiB; narrow the path or pattern";
+const decode = (bytes) => {
+	try {
+		return new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		}).decode(bytes);
+	} catch {
+		return;
+	}
+};
+const utf8Length = (text, from, to) => {
+	let bytes = 0;
+	for (let i = from; i < to; i += 1) {
+		const point = text.codePointAt(i) ?? 0;
+		if (point < 128) bytes += 1;
+		else if (point < 2048) bytes += 2;
+		else if (point > 65535 || point >= 55296 && point <= 56319) bytes += 4;
+		else if (point < 56320 || point > 57343) bytes += 3;
+	}
+	return bytes;
+};
+const runeStart = (bytes, at) => {
+	let i = at;
+	while (i > 0 && i < bytes.length && ((bytes[i] ?? 0) & 192) === 128) i -= 1;
+	return i;
+};
+const grepLine = ({ expression, limits }, every, out, name, number, lineAt, bytes, text) => {
+	if (bytes.length <= limits.lineBytes) {
+		if (expression.test(text)) out.push(`${name}:${number}:${text}\n`);
+		return;
+	}
+	every.lastIndex = 0;
+	let unit = 0;
+	let byte = 0;
+	let previousEnd = -1;
+	let count = 0;
+	while (count < limits.longLineMatches) {
+		const match = every.exec(text);
+		if (match === null) break;
+		const startUnit = match.index;
+		const endUnit = startUnit + match[0].length;
+		if (startUnit === endUnit) {
+			every.lastIndex = endUnit + 1;
+			if (startUnit === previousEnd) continue;
+		}
+		previousEnd = endUnit;
+		const startByte = byte + utf8Length(text, unit, startUnit);
+		const endByte = startByte + utf8Length(text, startUnit, endUnit);
+		unit = endUnit;
+		byte = endByte;
+		const from = runeStart(bytes, Math.max(0, startByte - limits.contextBytes));
+		const to = runeStart(bytes, Math.min(bytes.length, endByte + limits.contextBytes, startByte + limits.lineBytes));
+		out.push(`${name}:${number}:byte ${lineAt + startByte}:${bytes.toString("utf-8", from, to)}\n`);
+		count += 1;
+	}
+};
+const scan = (job, every, fd, name, used) => {
+	const { limits } = job;
+	let buffer = Buffer.allocUnsafe(limits.sniffBytes * 8);
+	let start = 0;
+	let end = 0;
+	let offset = 0;
+	let eof = false;
+	const fill = () => {
+		if (start > 0) {
+			buffer.copyWithin(0, start, end);
+			end -= start;
+			start = 0;
+		}
+		if (end === buffer.length) {
+			if (buffer.length >= limits.scanLineBytes) return false;
+			const grown = Buffer.allocUnsafe(Math.min(buffer.length * 2, limits.scanLineBytes));
+			buffer.copy(grown, 0, 0, end);
+			buffer = grown;
+		}
+		const count = readSync(fd, buffer, end, buffer.length - end, null);
+		if (count === 0) eof = true;
+		end += count;
+		return true;
+	};
+	while (end < limits.sniffBytes) {
+		fill();
+		if (eof) break;
+	}
+	if (buffer.subarray(0, Math.min(end, limits.sniffBytes)).includes(0)) return { skip: true };
+	const out = [];
+	let outSize = 0;
+	let number = 1;
+	for (;;) {
+		const newline = buffer.subarray(start, end).indexOf(10);
+		let line;
+		const lineAt = offset;
+		if (newline !== -1) {
+			line = buffer.subarray(start, start + newline);
+			start += newline + 1;
+			offset += newline + 1;
+		} else if (eof) {
+			if (start === end) break;
+			line = buffer.subarray(start, end);
+			offset += end - start;
+			start = end;
+		} else {
+			if (!fill()) return {
+				matches: out,
+				tooLong: number
+			};
+			continue;
+		}
+		if (line.length > 0 && line.at(-1) === 13) line = line.subarray(0, -1);
+		const text = line.includes(0) ? void 0 : decode(line);
+		if (text === void 0) return { notText: true };
+		const before = out.length;
+		grepLine(job, every, out, name, number, lineAt, line, text);
+		for (const found of out.slice(before)) outSize += Buffer.byteLength(found);
+		if (used + outSize > limits.resultBytes) throw new GrepError(tooLarge);
+		number += 1;
+	}
+	return { matches: out };
+};
+const runGrep = (job) => {
+	const { limits } = job;
+	const every = new RegExp(job.expression, "g");
+	let result = "";
+	let size = 0;
+	const add = (text) => {
+		result += text;
+		size += Buffer.byteLength(text);
+	};
+	const grepFile = (absolute, name) => {
+		let fd;
+		try {
+			fd = openSync(absolute, openFlags);
+		} catch (error) {
+			add(`skipped: open ${name}: ${reason(error)}\n`);
+			return;
+		}
+		try {
+			if (!fstatSync(fd).isFile()) return;
+			let outcome;
+			try {
+				outcome = scan(job, every, fd, name, size);
+			} catch (error) {
+				if (error instanceof GrepError) throw error;
+				add(`skipped: read ${name}: ${reason(error)}\n`);
+				return;
+			}
+			if ("skip" in outcome) return;
+			if ("notText" in outcome) {
+				add(`skipped: ${name} is not UTF-8 text; use read\n`);
+				return;
+			}
+			add(outcome.matches.join(""));
+			if (outcome.tooLong !== void 0) add(`skipped: ${name} from line ${outcome.tooLong}, which exceeds 16 MiB; use read\n`);
+		} finally {
+			closeSync(fd);
+		}
+	};
+	const walk = (absolute, name) => {
+		let entries;
+		try {
+			entries = readdirSync(absolute, { withFileTypes: true });
+		} catch (error) {
+			if (name === job.name) throw new GrepError(`walk ${name}: ${reason(error)}`);
+			add(`skipped: open ${name}: ${reason(error)}\n`);
+			return;
+		}
+		entries.sort((left, right) => {
+			if (left.name < right.name) return -1;
+			return left.name > right.name ? 1 : 0;
+		});
+		for (const entry of entries) {
+			const child = name === "." ? entry.name : `${name}/${entry.name}`;
+			const absoluteChild = path.join(absolute, entry.name);
+			if (entry.isDirectory()) walk(absoluteChild, child);
+			else if (entry.isFile()) grepFile(absoluteChild, child);
+			if (size > limits.resultBytes) throw new GrepError(tooLarge);
+		}
+	};
+	try {
+		if (job.kind === "directory") walk(job.root, job.name);
+		else if (job.kind === "file") grepFile(job.root, job.name);
+		if (size > limits.resultBytes) throw new GrepError(tooLarge);
+		return { text: size === 0 ? "no matches" : result };
+	} catch (error) {
+		if (!(error instanceof GrepError)) throw error;
+		return { error: `grep workspace: ${error.message}` };
+	}
+};
+parentPort?.once("message", (job) => {
+	parentPort?.postMessage(runGrep(job));
+});
+export {};

package/dist/io-BGJ4Yp7u.mjs

@@ -0,0 +1,19 @@
+import { Predicate } from "effect";
+import { constants } from "node:fs";
+// src/audit/io.ts
+const reasons = /* @__PURE__ */ new Map([
+	["ENOENT", "no such file or directory"],
+	["ENOTDIR", "not a directory"],
+	["EISDIR", "is a directory"],
+	["EACCES", "permission denied"],
+	["EPERM", "operation not permitted"],
+	["ELOOP", "too many levels of symbolic links"],
+	["EMFILE", "too many open files"],
+	["EIO", "input/output error"]
+]);
+const reason = (cause) => {
+	const code = cause instanceof Error && "code" in cause && Predicate.isString(cause.code) ? cause.code : void 0;
+	return code === void 0 ? "I/O error" : reasons.get(code) ?? code;
+};
+const openFlags = constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW;
+export { reason as n, openFlags as t };