@fusengine/harness 0.1.89 → 0.1.91

package/dist/cli/bin.mjs

@@ -3,9 +3,10 @@ import { o as resolveStdinMaxBytes } from "../limits-DG5pl-5s.mjs";
 import { c as resolveTtlSec, r as loadDotenv } from "../dotenv-BLBkBTww.mjs";
 import { t as detectHarness } from "../harness-BMuLJ9lm.mjs";
 import { t as claudeHome } from "../home-state-oUGFB4ds.mjs";
-import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-CdIlUtjv.mjs";
-import { n as writeInitFile, t as initFor } from "../run-TAXNRSpD.mjs";
-import { $ as runningVersion, Q as runDoctor, Z as notify, et as versionBanner, i as respond, t as handleHook, zt as todayUtc } from "../handle-DHhukRdh.mjs";
+import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-DkrzC0gb.mjs";
+import { n as writeInitFile, t as initFor } from "../run-GHAMqcOn.mjs";
+import { $ as runDoctor, Bt as todayUtc, Q as notify, et as runningVersion, i as respond, t as handleHook, tt as versionBanner } from "../handle-C43gA-Pr.mjs";
+import { r as cursorEventContract } from "../normalize-BjG6unTj.mjs";
 import { delimiter, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, readSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -999,6 +1000,386 @@ function parseScope(scopeArg, err = (m) => process.stderr.write(m)) {
 	return scopeArg !== void 0 && VALID_SCOPES.has(scopeArg) ? scopeArg : "core";
 }
 //#endregion
+//#region src/cli/json-primitive-scanner.ts
+/** Validate one JSON literal or number incrementally with constant state. */
+var JsonPrimitiveScanner = class {
+	literal;
+	literalIndex = 0;
+	number;
+	valid = true;
+	constructor(firstByte) {
+		if (firstByte === 116) {
+			this.literal = "true";
+			this.literalIndex = 1;
+		} else if (firstByte === 102) {
+			this.literal = "false";
+			this.literalIndex = 1;
+		} else if (firstByte === 110) {
+			this.literal = "null";
+			this.literalIndex = 1;
+		} else if (firstByte === 45) this.number = "minus";
+		else if (firstByte === 48) this.number = "zero";
+		else if (isOneToNine(firstByte)) this.number = "integer";
+		else this.valid = false;
+	}
+	/** Consume one non-delimiter byte and report whether the prefix stays valid. */
+	write(byte) {
+		if (!this.valid) return false;
+		if (this.literal) {
+			this.valid = this.literal.charCodeAt(this.literalIndex) === byte;
+			this.literalIndex += 1;
+			return this.valid && this.literalIndex <= this.literal.length;
+		}
+		this.valid = this.writeNumber(byte);
+		return this.valid;
+	}
+	/** Return whether the accumulated primitive is complete JSON grammar. */
+	finish() {
+		if (!this.valid) return false;
+		if (this.literal) return this.literalIndex === this.literal.length;
+		return this.number === "zero" || this.number === "integer" || this.number === "fraction" || this.number === "exponent";
+	}
+	writeNumber(byte) {
+		if (this.number === "minus") return this.digitAfter(byte, "zero", "integer");
+		if (this.number === "zero") return this.afterInteger(byte, false);
+		if (this.number === "integer") {
+			if (isDigit(byte)) return true;
+			return this.afterInteger(byte, true);
+		}
+		if (this.number === "dot") {
+			if (!isDigit(byte)) return false;
+			this.number = "fraction";
+			return true;
+		}
+		if (this.number === "fraction") {
+			if (isDigit(byte)) return true;
+			return this.startExponent(byte);
+		}
+		if (this.number === "exponentMark") {
+			if (byte === 43 || byte === 45) {
+				this.number = "exponentSign";
+				return true;
+			}
+			return this.digitAfter(byte, "exponent", "exponent");
+		}
+		if (this.number === "exponentSign") return this.digitAfter(byte, "exponent", "exponent");
+		return this.number === "exponent" && isDigit(byte);
+	}
+	afterInteger(byte, digitAllowed) {
+		if (digitAllowed && isDigit(byte)) return true;
+		if (byte === 46) {
+			this.number = "dot";
+			return true;
+		}
+		return this.startExponent(byte);
+	}
+	startExponent(byte) {
+		if (byte !== 101 && byte !== 69) return false;
+		this.number = "exponentMark";
+		return true;
+	}
+	digitAfter(byte, zero, nonzero) {
+		if (byte === 48) {
+			this.number = zero;
+			return true;
+		}
+		if (isOneToNine(byte)) {
+			this.number = nonzero;
+			return true;
+		}
+		return false;
+	}
+};
+function isDigit(byte) {
+	return byte >= 48 && byte <= 57;
+}
+function isOneToNine(byte) {
+	return byte >= 49 && byte <= 57;
+}
+//#endregion
+//#region src/cli/cursor-event-scanner.ts
+/**
+* Fixed cardinality bounds used by the incremental Cursor JSON scanner.
+* `maxDepth` counts simultaneously open containers. Deeper valid JSON remains
+* indeterminate and the oversized Cursor path fails closed.
+*/
+const CURSOR_SCANNER_LIMITS = {
+	tokenEntries: 256,
+	maxDepth: 1024
+};
+/** Incrementally validates JSON and extracts the last top-level Cursor event name. */
+var CursorEventScanner = class {
+	frames = [];
+	mode = "normal";
+	token = [];
+	tokenOverflow = false;
+	primitive;
+	escaped = false;
+	unicode = 0;
+	rootStarted = false;
+	rootComplete = false;
+	invalid = false;
+	event;
+	/** Consume another raw JSON byte chunk without retaining the payload. */
+	write(chunk) {
+		for (const byte of chunk) this.consume(byte);
+	}
+	/** Return the event only when the complete stream is valid JSON. */
+	finish() {
+		if (this.mode === "primitive") this.endPrimitive();
+		if (this.mode !== "normal" || this.frames.length > 0 || !this.rootComplete) this.invalid = true;
+		return this.invalid ? void 0 : this.event;
+	}
+	consume(byte) {
+		if (this.invalid) return;
+		if (this.mode === "string") {
+			this.stringByte(byte);
+			return;
+		}
+		if (this.mode === "primitive") {
+			if (!isDelimiter(byte)) {
+				if (!this.primitive?.write(byte)) this.invalid = true;
+				return;
+			}
+			this.endPrimitive();
+			if (this.invalid) return;
+		}
+		if (isWhitespace(byte)) return;
+		if (byte === 34) {
+			this.startString();
+			return;
+		}
+		if (byte === 123 || byte === 91) {
+			this.startContainer(byte === 123 ? "object" : "array");
+			return;
+		}
+		if (byte === 125 || byte === 93) {
+			this.endContainer(byte === 125 ? "object" : "array");
+			return;
+		}
+		if (byte === 58) {
+			this.colon();
+			return;
+		}
+		if (byte === 44) {
+			this.comma();
+			return;
+		}
+		if (isPrimitiveStart(byte)) {
+			this.startPrimitive(byte);
+			return;
+		}
+		this.invalid = true;
+	}
+	startString() {
+		this.mode = "string";
+		this.token = [34];
+		this.tokenOverflow = false;
+		this.escaped = false;
+		this.unicode = 0;
+	}
+	startPrimitive(byte) {
+		this.mode = "primitive";
+		this.primitive = new JsonPrimitiveScanner(byte);
+	}
+	stringByte(byte) {
+		this.pushToken(byte);
+		if (this.unicode > 0) {
+			if (!isHex(byte)) {
+				this.invalid = true;
+				return;
+			}
+			this.unicode -= 1;
+			return;
+		}
+		if (this.escaped) {
+			if (byte === 117) this.unicode = 4;
+			else if (![
+				34,
+				92,
+				47,
+				98,
+				102,
+				110,
+				114,
+				116
+			].includes(byte)) this.invalid = true;
+			this.escaped = false;
+			return;
+		}
+		if (byte === 92) {
+			this.escaped = true;
+			return;
+		}
+		if (byte < 32) {
+			this.invalid = true;
+			return;
+		}
+		if (byte !== 34) return;
+		this.mode = "normal";
+		const value = this.tokenOverflow ? void 0 : decodeString(this.token);
+		if (value === null) {
+			this.invalid = true;
+			return;
+		}
+		this.acceptString(value);
+	}
+	acceptString(value) {
+		const frame = this.frames.at(-1);
+		if (frame?.kind === "object" && (frame.state === "key" || frame.state === "keyOrEnd")) {
+			frame.key = value;
+			frame.state = "colon";
+			return;
+		}
+		this.acceptValue("string", value);
+	}
+	startContainer(kind) {
+		this.acceptValue(kind);
+		if (this.invalid) return;
+		if (this.frames.length >= CURSOR_SCANNER_LIMITS.maxDepth) {
+			this.invalid = true;
+			return;
+		}
+		this.frames.push(kind === "object" ? {
+			kind,
+			state: "keyOrEnd"
+		} : {
+			kind,
+			state: "valueOrEnd"
+		});
+	}
+	endContainer(kind) {
+		const frame = this.frames.at(-1);
+		if (!(frame?.kind === kind && (kind === "object" ? frame.state === "keyOrEnd" || frame.state === "commaOrEnd" : frame.state === "valueOrEnd" || frame.state === "commaOrEnd"))) {
+			this.invalid = true;
+			return;
+		}
+		this.frames.pop();
+		if (this.frames.length === 0) this.rootComplete = true;
+	}
+	acceptValue(kind, value) {
+		if (this.rootComplete) {
+			this.invalid = true;
+			return;
+		}
+		const frame = this.frames.at(-1);
+		if (!frame) {
+			if (this.rootStarted) {
+				this.invalid = true;
+				return;
+			}
+			this.rootStarted = true;
+			if (kind === "string" || kind === "primitive") this.rootComplete = true;
+			return;
+		}
+		if (!(frame.kind === "object" ? frame.state === "value" : frame.state === "value" || frame.state === "valueOrEnd")) {
+			this.invalid = true;
+			return;
+		}
+		if (frame.kind === "object") {
+			if (this.frames.length === 1 && frame.key === "hook_event_name") this.event = kind === "string" ? value : void 0;
+			frame.key = void 0;
+		}
+		frame.state = "commaOrEnd";
+	}
+	colon() {
+		const frame = this.frames.at(-1);
+		if (frame?.kind !== "object" || frame.state !== "colon") {
+			this.invalid = true;
+			return;
+		}
+		frame.state = "value";
+	}
+	comma() {
+		const frame = this.frames.at(-1);
+		if (!frame || frame.state !== "commaOrEnd") {
+			this.invalid = true;
+			return;
+		}
+		frame.state = frame.kind === "object" ? "key" : "value";
+	}
+	endPrimitive() {
+		const valid = this.primitive?.finish() === true;
+		this.mode = "normal";
+		this.primitive = void 0;
+		if (valid) this.acceptValue("primitive");
+		else this.invalid = true;
+	}
+	pushToken(byte) {
+		if (this.token.length < CURSOR_SCANNER_LIMITS.tokenEntries) this.token.push(byte);
+		else this.tokenOverflow = true;
+	}
+};
+function decodeString(bytes) {
+	try {
+		const value = JSON.parse(Buffer.from(bytes).toString("utf8"));
+		return typeof value === "string" ? value : null;
+	} catch {
+		return null;
+	}
+}
+function isWhitespace(byte) {
+	return byte === 32 || byte === 9 || byte === 10 || byte === 13;
+}
+function isDelimiter(byte) {
+	return isWhitespace(byte) || [
+		44,
+		93,
+		125
+	].includes(byte);
+}
+function isPrimitiveStart(byte) {
+	return byte === 45 || byte === 116 || byte === 102 || byte === 110 || byte >= 48 && byte <= 57;
+}
+function isHex(byte) {
+	return byte >= 48 && byte <= 57 || byte >= 65 && byte <= 70 || byte >= 97 && byte <= 102;
+}
+//#endregion
+//#region src/cli/cursor-stdin-reader.ts
+const HEAD_BYTES$1 = 4096;
+const CHUNK_BYTES = 64 * 1024;
+/**
+* Read Cursor stdin through EOF for valid top-level event classification.
+* Cursor's host-configured execution timeout bounds an idle open pipe.
+*/
+function readCursorBounded(fd, maxBytes) {
+	const chunk = Buffer.alloc(CHUNK_BYTES);
+	const head = Buffer.alloc(HEAD_BYTES$1);
+	const retained = Buffer.alloc(maxBytes);
+	const scanner = new CursorEventScanner();
+	let headLength = 0;
+	let retainedLength = 0;
+	let total = 0;
+	let oversize = false;
+	for (;;) {
+		const length = readSync(fd, chunk, 0, CHUNK_BYTES, null);
+		if (length === 0) break;
+		const view = chunk.subarray(0, length);
+		scanner.write(view);
+		total += length;
+		if (headLength < HEAD_BYTES$1) {
+			const copied = Math.min(length, HEAD_BYTES$1 - headLength);
+			view.copy(head, headLength, 0, copied);
+			headLength += copied;
+		}
+		if (!oversize) {
+			const copied = Math.min(length, Math.max(0, maxBytes - retainedLength));
+			if (copied > 0) view.copy(retained, retainedLength, 0, copied);
+			retainedLength += copied;
+			if (total > maxBytes) oversize = true;
+		}
+	}
+	if (!oversize) return {
+		kind: "ok",
+		text: retained.subarray(0, total).toString("utf8")
+	};
+	const event = scanner.finish();
+	return {
+		kind: "oversize",
+		head: event ? JSON.stringify({ hook_event_name: event }) : head.subarray(0, headLength).toString("utf8")
+	};
+}
+//#endregion
 //#region src/cli/hook-io.ts
 /**
 * Hook stdin reading + debug tracing for `harness hook` — extracted from
@@ -1006,22 +1387,34 @@ function parseScope(scopeArg, err = (m) => process.stderr.write(m)) {
 * Tracing is stderr-only and active only when FUSE_HARNESS_DEBUG=1 AND
 * CI=true (both set by test/sim/exec.ts; never in an interactive session).
 *
-* Stdin is read BOUNDED (`resolveStdinMaxBytes`, default 16 MiB): the reader
-* never buffers past the cap, so an oversized payload cannot exhaust memory
-* nor slip an uninspected tool call through (fail-closed — see `bin.ts`).
+* `resolveStdinMaxBytes` (default 16 MiB) caps retained payload content.
+* The legacy reader may also retain its overflow chunk; Cursor additionally
+* requests fixed scanner/chunk buffers while reading to EOF. Buffer alias views,
+* JS objects/strings, and RSS are runtime-dependent, so this is not a physical
+* memory guarantee. Unclassified oversized Cursor input fails closed.
 */
 const hookDebug = process.env.FUSE_HARNESS_DEBUG === "1" && process.env.CI === "true";
 /** stderr-only trace, no-op outside the debug flag combination above. */
 function traceHook(label, data) {
 	if (hookDebug) process.stderr.write(`[hook-debug] ${label}: ${typeof data === "string" ? data : JSON.stringify(data)}\n`);
 }
+const MALFORMED_STDIN = Symbol("cursor-malformed-stdin");
 /** Type guard for the oversize variant (narrows the readStdin union). */
 function isOversize(x) {
 	return typeof x === "object" && x !== null && x.kind === "oversize";
 }
-/** First 4 KiB are kept on oversize for event-name sniffing downstream. */
+/** Identify Cursor JSON parse failures without accepting a forgeable payload field. */
+function isMalformedCursorStdin(x) {
+	return typeof x === "object" && x !== null && MALFORMED_STDIN in x;
+}
+/** First 4 KiB are the fallback diagnostic probe when no event key is found. */
 const HEAD_BYTES = 4096;
 const CHUNK = 64 * 1024;
+const CURSOR_MAX_STDIN_BYTES = 64 * 1024 * 1024;
+/** Resolve and clamp Cursor's stdin cap while preserving other harness limits. */
+function resolveCursorStdinMaxBytes(env = process.env) {
+	return Math.min(CURSOR_MAX_STDIN_BYTES, resolveStdinMaxBytes(env));
+}
 /**
 * Read a file descriptor to EOF, bounded at `maxBytes` (+1 byte to detect
 * the overflow). Injectable fd so tests never touch process stdin.
@@ -1048,9 +1441,10 @@ function readBounded(fd, maxBytes) {
 		text: Buffer.concat(parts).toString("utf8")
 	};
 }
-/** Read the hook payload from stdin; `{}` on empty or invalid JSON (fail-open parity). */
-async function readStdin() {
-	const read = readBounded(0, resolveStdinMaxBytes());
+/** Read hook stdin; Cursor distinguishes malformed non-empty JSON from historical empty input. */
+async function readStdin(id) {
+	const cap = id === "cursor" ? resolveCursorStdinMaxBytes() : resolveStdinMaxBytes();
+	const read = id === "cursor" ? readCursorBounded(0, cap) : readBounded(0, cap);
 	if (read.kind === "oversize") return read;
 	const text = read.text.trim();
 	if (!text) return {};
@@ -1059,7 +1453,7 @@ async function readStdin() {
 		return typeof parsed === "object" && parsed !== null ? parsed : {};
 	} catch (e) {
 		traceHook("stdin-parse-error", e instanceof Error ? e.message : String(e));
-		return {};
+		return id === "cursor" ? { [MALFORMED_STDIN]: true } : {};
 	}
 }
 /** Blockable hook events (fail-closed on oversize); others are observation-only. */
@@ -1076,13 +1470,31 @@ const BLOCKABLE = /* @__PURE__ */ new Set([
 * @param head - The first bytes of the payload (event-name sniffing).
 */
 function oversizeStdout(id, head) {
-	const event = /"hook_event_name"\s*:\s*"([^"]+)"/.exec(head)?.[1] ?? "";
-	if (event && !BLOCKABLE.has(event)) return "";
+	const event = id === "cursor" ? probeEvent(head) : legacyProbeEvent(head);
+	const maxBytes = id === "cursor" ? resolveCursorStdinMaxBytes() : resolveStdinMaxBytes();
+	if (id === "cursor" && event) {
+		const contract = cursorEventContract(event);
+		if (!contract.known || !contract.blockable) return "{}";
+	}
+	if (id !== "cursor" && event && !BLOCKABLE.has(event)) return "";
 	return respond(id, {
 		kind: "block",
 		title: "Oversize hook payload",
-		reason: `stdin payload exceeds ${resolveStdinMaxBytes()} bytes — denied uninspected`
-	});
+		reason: `stdin payload exceeds ${maxBytes} bytes — denied uninspected`
+	}, id === "cursor" ? event || "preToolUse" : "PreToolUse");
+}
+function legacyProbeEvent(head) {
+	return /"hook_event_name"\s*:\s*"([^"]+)"/.exec(head)?.[1] ?? "";
+}
+function probeEvent(head) {
+	try {
+		const parsed = JSON.parse(head);
+		if (typeof parsed !== "object" || parsed === null) return "";
+		const event = parsed.hook_event_name;
+		return typeof event === "string" ? event : "";
+	} catch {
+		return "";
+	}
 }
 //#endregion
 //#region src/cli/hook-sound.ts
@@ -1166,12 +1578,13 @@ if (cmd === "--version" || cmd === "-v") {
 	});
 	let outcome;
 	try {
-		const stdin = await readStdin();
+		const stdin = await readStdin(id);
 		if (isOversize(stdin)) {
 			const stdout = oversizeStdout(id, stdin.head);
 			if (stdout) process.stdout.write(stdout);
 			process.exit(0);
 		}
+		if (isMalformedCursorStdin(stdin)) process.exit(1);
 		outcome = await handleHook(id, stdin, {
 			now: Date.now(),
 			cwd: process.cwd(),

package/dist/cli/index.mjs

@@ -1,2 +1,2 @@
-import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-CdIlUtjv.mjs";
+import { n as stagedContent, r as stagedFiles, t as checkStaged } from "../run-DkrzC0gb.mjs";
 export { checkStaged, stagedContent, stagedFiles };

package/dist/command-string-CALMTnwN.mjs

@@ -0,0 +1,42 @@
+//#region src/runtime/command-string.ts
+/** Shell basenames whose `-c`-style argv carries the real script in argv[2]. */
+const SHELLS = /* @__PURE__ */ new Set([
+	"bash",
+	"sh",
+	"zsh",
+	"dash"
+]);
+/** True when `arg` is (a path to) a POSIX shell we know wraps a `-c` script. */
+function isShell(arg) {
+	if (arg === void 0) return false;
+	const base = arg.slice(arg.lastIndexOf("/") + 1);
+	return SHELLS.has(base);
+}
+/** True for a shell command flag (`-c`, `-lc`, `-ic`, …) — anything ending in `c`. */
+function isCommandFlag(arg) {
+	return arg !== void 0 && /^-[a-z]*c$/.test(arg);
+}
+/**
+* Coerce a hook payload's `command` field to the shell string the guard chain
+* expects. Harnesses disagree on the wire shape: Claude Code, Cursor, and Hermes
+* send a plain string, but Codex CLI sends an argv ARRAY
+* (`["bash", "-lc", "git commit -m x"]`). A naive `typeof === "string"` check
+* dropped the array to `undefined`, blinding every `ctx.command` guard
+* (destructive-git, mutators, install…) into a silent fail-open. This restores
+* the script so the array and string payloads reach an identical verdict.
+*
+* @param v - Raw `command` value off the payload (string, argv array, or other).
+* @returns A string as-is; a `[shell, -c|-lc, script]` argv reduced to its
+*   script; any other all-string array joined with spaces; and `undefined` for
+*   empty arrays, arrays holding non-strings, or any other type.
+*/
+function commandToString(v) {
+	if (typeof v === "string") return v;
+	if (!Array.isArray(v)) return void 0;
+	if (v.length === 0 || !v.every((e) => typeof e === "string")) return void 0;
+	const argv = v;
+	if (argv.length >= 3 && isShell(argv[0]) && isCommandFlag(argv[1])) return argv[2];
+	return argv.join(" ");
+}
+//#endregion
+export { commandToString as t };