pi-crew 0.9.15 → 0.9.17

package/src/utils/redaction.ts

@@ -120,7 +120,7 @@ export function isSecretKey(keyName: string): boolean {
 // Boundary chars that may precede an "authorization:" or "Bearer " keyword.
 // Includes '-' so prefixed headers (Proxy-Authorization, X-Authorization) and
 // '\t' so tab-indented headers are recognized. See security review L5.
-const AUTH_HEADER_BOUNDARY_CHARS = new Set([" ", ",", "{", "[", "\"", "\r", "\n", "-", "\t"]);
+const AUTH_HEADER_BOUNDARY_CHARS = new Set([" ", ",", "{", "[", '"', "\r", "\n", "-", "\t"]);
 function isAuthHeaderBoundary(ch: string | undefined): boolean {
 	return ch !== undefined && AUTH_HEADER_BOUNDARY_CHARS.has(ch);
 }
@@ -133,8 +133,8 @@ function isAuthHeaderBoundary(ch: string | undefined): boolean {
 export function redactAuthHeader(line: string): string {
 	const lower = line.toLowerCase();
 	let result = "";
-	let i = 0;          // emit cursor into the original `line`
-	let searchFrom = 0;  // cursor for the next indexOf scan
+	let i = 0; // emit cursor into the original `line`
+	let searchFrom = 0; // cursor for the next indexOf scan
 	for (;;) {
 		const authIdx = lower.indexOf("authorization:", searchFrom);
 		if (authIdx === -1) {
@@ -172,7 +172,7 @@ export function redactBearerTokens(line: string): string {
 	const upper = line.toUpperCase();
 	const result: string[] = [];
 	let i = 0;
-	
+
 	while (i < line.length) {
 		if (upper.startsWith("BEARER ", i)) {
 			// Check word boundary: start-of-string or a boundary char. Includes '-'
@@ -182,7 +182,7 @@ export function redactBearerTokens(line: string): string {
 				i++;
 				continue;
 			}
-			
+
 			// Found "Bearer " - now find the token
 			const bearerPrefix = line.substring(i, i + 7); // "Bearer "
 			let j = i + 7;
@@ -191,7 +191,7 @@ export function redactBearerTokens(line: string): string {
 				j++;
 				tokenLen++;
 			}
-			
+
 			if (tokenLen >= 8) {
 				// Replace with Bearer + *** (redact the token)
 				result.push(bearerPrefix + "***");
@@ -202,29 +202,30 @@ export function redactBearerTokens(line: string): string {
 		result.push(line[i]);
 		i++;
 	}
-	
+
 	return result.join("");
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	if (value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof Map || value instanceof Set) return false;
+	if (value instanceof Date || value instanceof RegExp || value instanceof Error || value instanceof Map || value instanceof Set)
+		return false;
 	return true;
 }
 
 export function redactSecretString(value: string): string {
 	let result = value;
-	
+
 	// Replace PEM private keys
 	result = result.replace(PEM_PRIVATE_KEY_PATTERN, "***");
-	
+
 	// Replace Authorization headers (non-Bearer format)
 	result = redactAuthHeader(result);
-	
+
 	// Replace Bearer tokens (run before structured-token patterns so a
 	// "Bearer <jwt>" pair is collapsed first; bare tokens are caught below).
 	result = redactBearerTokens(result);
-	
+
 	// P1f: structured secret tokens (JWT / GitHub PAT / AWS keys + optional
 	// Slack/Google/Stripe). Best-effort vs adversarial workers (see note above).
 	result = result
@@ -234,10 +235,10 @@ export function redactSecretString(value: string): string {
 		.replace(SLACK_TOKEN_PATTERN, "***")
 		.replace(GOOGLE_API_KEY_PATTERN, "***")
 		.replace(STRIPE_KEY_PATTERN, "***");
-	
+
 	// Replace inline secrets: key=value or key:value patterns
 	result = redactInlineSecrets(result);
-	
+
 	return result;
 }
 
@@ -254,8 +255,8 @@ export function redactSecretString(value: string): string {
 function isKeyChar(c: string): boolean {
 	const code = c.charCodeAt(0);
 	return (
-		(code >= 48 && code <= 57) ||  // 0-9
-		(code >= 65 && code <= 90) ||  // A-Z
+		(code >= 48 && code <= 57) || // 0-9
+		(code >= 65 && code <= 90) || // A-Z
 		(code >= 97 && code <= 122) || // a-z
 		code === 95 || // _
 		code === 45 // -
@@ -275,7 +276,7 @@ function redactInlineSecrets(value: string): string {
 		const keyLen = j - i;
 
 		let redacted = false;
-		if (keyLen > 0 && j < value.length && (value[j] === '=' || value[j] === ':')) {
+		if (keyLen > 0 && j < value.length && (value[j] === "=" || value[j] === ":")) {
 			const key = value.substring(i, j);
 
 			// Check if this is a secret key
@@ -284,7 +285,16 @@ function redactInlineSecrets(value: string): string {
 				const sep = value[j];
 				let k = j + 1;
 				let valLen = 0;
-				while (k < value.length && valLen < 500 && value[k] !== ' ' && value[k] !== ',' && value[k] !== ';' && value[k] !== '"' && value[k] !== '\r' && value[k] !== '\n') {
+				while (
+					k < value.length &&
+					valLen < 500 &&
+					value[k] !== " " &&
+					value[k] !== "," &&
+					value[k] !== ";" &&
+					value[k] !== '"' &&
+					value[k] !== "\r" &&
+					value[k] !== "\n"
+				) {
 					k++;
 					valLen++;
 				}
@@ -334,4 +344,4 @@ export function redactJsonLine(line: string): string {
 	} catch {
 		return redactSecretString(line);
 	}
-}
+}

package/src/utils/resolve-shell.ts

@@ -5,11 +5,7 @@ import * as fs from "node:fs";
  */
 export function resolveBashCmd(): string {
 	if (process.platform !== "win32") return "bash";
-	const candidates = [
-		process.env.SHELL,
-		"C:\\Program Files\\Git\\bin\\bash.exe",
-		"C:\\Program Files (x86)\\Git\\bin\\bash.exe",
-	];
+	const candidates = [process.env.SHELL, "C:\\Program Files\\Git\\bin\\bash.exe", "C:\\Program Files (x86)\\Git\\bin\\bash.exe"];
 	for (const cand of candidates) {
 		if (cand && fs.existsSync(cand)) return cand;
 	}
@@ -20,14 +16,20 @@ export function resolveBashCmd(): string {
  * Choose the right shell command and arguments for a script path.
  * On Windows, powershell (.ps1) and batch (.cmd/.bat) run natively.
  */
-export function resolveShellForScript(scriptPath: string): { command: string; args: string[] } {
+export function resolveShellForScript(scriptPath: string): {
+	command: string;
+	args: string[];
+} {
 	if (process.platform === "win32") {
 		if (scriptPath.endsWith(".ps1")) {
 			return { command: "powershell", args: ["-File", scriptPath] };
 		}
 		if (scriptPath.endsWith(".cmd") || scriptPath.endsWith(".bat")) {
 			// Node >= 20 blocks direct spawn of .bat/.cmd without shell (CVE-2024-27980)
-			return { command: process.env.ComSpec ?? "cmd.exe", args: ["/d", "/s", "/c", scriptPath] };
+			return {
+				command: process.env.ComSpec ?? "cmd.exe",
+				args: ["/d", "/s", "/c", scriptPath],
+			};
 		}
 	}
 	return { command: resolveBashCmd(), args: [scriptPath] };

package/src/utils/run-watcher-registry.ts

@@ -46,29 +46,26 @@ export class RunWatcherRegistry {
 	 * brand-new run, because `crew.run.created` is never emitted by the runtime
 	 * (confirmed: only `crew.run.completed/failed/cancelled` are emitted).
 	 */
-	setRootWatcher(
-		runsDir: string,
-		onNewRun: RunChangeCallback,
-		onError?: ErrorCallback,
-	): void {
+	setRootWatcher(runsDir: string, onNewRun: RunChangeCallback, onError?: ErrorCallback): void {
 		if (this.closed) return;
 		// Replace any prior root watcher.
 		closeWatcher(this.rootWatcher);
-		this.rootWatcher = watchWithErrorHandler(
-			runsDir,
-			(_eventType, filename) => {
-				if (typeof filename !== "string" || filename.length === 0) return;
-				// fs.watch reports directory entries as bare names (no slash on Linux).
-				// A new run dir appears as `runs/<runId>` → filename = "<runId>".
-				// Filter obviously-not-run-id noise (files, temp, etc.) defensively.
-				const candidate = filename.replace(/\\/g, "/").split("/")[0];
-				if (candidate.length === 0) return;
-				onNewRun(candidate);
-			},
-			(error) => {
-				if (onError) onError(error);
-			},
-		) ?? undefined;
+		this.rootWatcher =
+			watchWithErrorHandler(
+				runsDir,
+				(_eventType, filename) => {
+					if (typeof filename !== "string" || filename.length === 0) return;
+					// fs.watch reports directory entries as bare names (no slash on Linux).
+					// A new run dir appears as `runs/<runId>` → filename = "<runId>".
+					// Filter obviously-not-run-id noise (files, temp, etc.) defensively.
+					const candidate = filename.replace(/\\/g, "/").split("/")[0];
+					if (candidate.length === 0) return;
+					onNewRun(candidate);
+				},
+				(error) => {
+					if (onError) onError(error);
+				},
+			) ?? undefined;
 	}
 
 	/**
@@ -76,12 +73,7 @@ export class RunWatcherRegistry {
 	 * inotify watch. If a watcher for this runId already exists, close + replace.
 	 * Returns true if a watcher is now active for this runId.
 	 */
-	addRunWatcher(
-		runId: string,
-		runDir: string,
-		onChange: RunChangeCallback,
-		onError?: ErrorCallback,
-	): boolean {
+	addRunWatcher(runId: string, runDir: string, onChange: RunChangeCallback, onError?: ErrorCallback): boolean {
 		if (this.closed) return false;
 		const existing = this.runWatchers.get(runId);
 		if (existing) closeWatcher(existing);
@@ -121,11 +113,7 @@ export class RunWatcherRegistry {
 	 * not yet watched, remove watchers for runs that left the active set. Returns
 	 * which runIds were added / removed (useful for logging + tests).
 	 */
-	reconcile(
-		activeRuns: ActiveRun[],
-		onChange: RunChangeCallback,
-		onError?: ErrorCallback,
-	): ReconcileResult {
+	reconcile(activeRuns: ActiveRun[], onChange: RunChangeCallback, onError?: ErrorCallback): ReconcileResult {
 		if (this.closed) return { added: [], removed: [] };
 		const activeIds = new Set(activeRuns.map((r) => r.runId));
 		const added: string[] = [];

package/src/utils/safe-paths.ts

@@ -11,7 +11,7 @@ export function assertSafePathId(kind: string, value: string): string {
 }
 
 export function resolveContainedPath(baseDir: string, targetPath: string): string {
-	if (targetPath.includes('\0')) {
+	if (targetPath.includes("\0")) {
 		throw new Error(`Security: path contains null byte`);
 	}
 	const base = path.resolve(baseDir);
@@ -23,9 +23,10 @@ export function resolveContainedPath(baseDir: string, targetPath: string): strin
 	// OS-managed symlink is wrongly rejected as "outside" the base.
 	const baseNorm = resolveCanonicalPath(base);
 	const resolvedNorm = resolveCanonicalPath(resolved);
-	const relative = process.platform === "win32"
-		? path.relative(baseNorm.toLowerCase(), resolvedNorm.toLowerCase())
-		: path.relative(baseNorm, resolvedNorm);
+	const relative =
+		process.platform === "win32"
+			? path.relative(baseNorm.toLowerCase(), resolvedNorm.toLowerCase())
+			: path.relative(baseNorm, resolvedNorm);
 	if (relative.startsWith("..") || path.isAbsolute(relative)) throw new Error(`Path is outside ${baseDir}: ${targetPath}`);
 	return resolved;
 }
@@ -57,7 +58,9 @@ function resolveCanonicalPath(p: string): string {
 				let acc = real;
 				for (let i = parts.length - 1; i >= 0; i--) acc = path.join(acc, parts[i]);
 				return acc;
-			} catch { /* keep walking up */ }
+			} catch {
+				/* keep walking up */
+			}
 			parts.push(path.basename(current));
 			current = path.dirname(current);
 		}
@@ -91,14 +94,20 @@ function resolveWindowsCanonical(p: string): string {
 		try {
 			const real = fs.realpathSync(p);
 			return real;
-		} catch { /* proceed to ancestor walk */ }
+		} catch {
+			/* proceed to ancestor walk */
+		}
 		// Walk up to find the deepest existing ancestor
 		const parts: string[] = [];
 		let current = p;
 		while (current !== path.dirname(current)) {
 			try {
 				let real: string;
-				try { real = fs.realpathSync.native(current); } catch { real = fs.realpathSync(current); }
+				try {
+					real = fs.realpathSync.native(current);
+				} catch {
+					real = fs.realpathSync(current);
+				}
 				// Guard against NTFS internal paths
 				if (real.includes("$Extend") || real.includes("$Deleted")) throw new Error("NTFS internal path");
 				// Found existing ancestor — join with remaining parts in reverse order
@@ -107,7 +116,9 @@ function resolveWindowsCanonical(p: string): string {
 					real = path.join(real, parts[i]);
 				}
 				return real;
-			} catch { /* keep walking */ }
+			} catch {
+				/* keep walking */
+			}
 			parts.push(path.basename(current));
 			current = path.dirname(current);
 		}
@@ -161,7 +172,7 @@ function resolveWindowsCanonical(p: string): string {
  * operation is atomic and prevents TOCTOU attacks.
  */
 export function resolveRealContainedPath(baseDir: string, targetPath: string): string {
-	if (targetPath.includes('\0')) {
+	if (targetPath.includes("\0")) {
 		throw new Error(`Security: path contains null byte`);
 	}
 	const resolved = resolveContainedPath(baseDir, targetPath);
@@ -179,7 +190,9 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 				fs.mkdirSync(baseDir, { recursive: true });
 				baseFd = fs.openSync(baseDir, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
 			} catch (retryError) {
-				throw new Error(`Cannot open base directory ${baseDir}: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+				throw new Error(
+					`Cannot open base directory ${baseDir}: ${retryError instanceof Error ? retryError.message : String(retryError)}`,
+				);
 			}
 		} else if (errCode === "ELOOP") {
 			// On macOS, system directories like /var → /private/var contain symlinks.
@@ -192,7 +205,9 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 						baseDir = realBaseDir; // update for later use
 						// Fall through to fstatSync below
 					}
-				} catch { /* throw original */ }
+				} catch {
+					/* throw original */
+				}
 			}
 			if (baseFd === undefined) throw new Error("Refusing to resolve: baseDir path contains a symlink: " + baseDir);
 		} else {
@@ -235,15 +250,15 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 			fs.closeSync(fd);
 		} catch (error) {
 			if ((error as NodeJS.ErrnoException).code === "ELOOP") {
-			// On macOS, /var → /private/var, /tmp → /private/tmp, /etc → /private/etc
-			// are system symlinks managed by the OS. Allow them.
-			if (process.platform === "darwin") {
-				const resolvedSymlink = resolvedAccumulated;
-				const knownDarwinSymlinks = ["/var", "/tmp", "/etc", "/private/var", "/private/tmp", "/private/etc"];
-				if (knownDarwinSymlinks.includes(resolvedSymlink)) continue;
+				// On macOS, /var → /private/var, /tmp → /private/tmp, /etc → /private/etc
+				// are system symlinks managed by the OS. Allow them.
+				if (process.platform === "darwin") {
+					const resolvedSymlink = resolvedAccumulated;
+					const knownDarwinSymlinks = ["/var", "/tmp", "/etc", "/private/var", "/private/tmp", "/private/etc"];
+					if (knownDarwinSymlinks.includes(resolvedSymlink)) continue;
+				}
+				throw new Error("Refusing to resolve: target path ancestor is a symlink: " + resolvedAccumulated);
 			}
-			throw new Error("Refusing to resolve: target path ancestor is a symlink: " + resolvedAccumulated);
-		}
 			// EPERM on Windows when opening a directory — skip validation
 			if ((error as NodeJS.ErrnoException).code === "EPERM" && process.platform === "win32") continue;
 			// ENOENT means component doesn't exist — that's OK. Only existing symlinks
@@ -265,7 +280,8 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 	try {
 		targetFd = fs.openSync(resolved, O_RDONLY | O_NOFOLLOW);
 	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ELOOP") throw new Error("Refusing to resolve: target path is a symlink: " + resolved);
+		if ((error as NodeJS.ErrnoException).code === "ELOOP")
+			throw new Error("Refusing to resolve: target path is a symlink: " + resolved);
 		// EPERM on Windows when opening a directory — treat as non-existent
 		if ((error as NodeJS.ErrnoException).code === "EPERM" && process.platform === "win32") return resolved;
 		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
@@ -288,7 +304,9 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 			// We already validated all ancestors are not symlinks above.
 			return resolved;
 		}
-		throw new Error(`Cannot resolve real path of ${resolved}: ${targetError instanceof Error ? targetError.message : String(targetError)}`);
+		throw new Error(
+			`Cannot resolve real path of ${resolved}: ${targetError instanceof Error ? targetError.message : String(targetError)}`,
+		);
 	} finally {
 		fs.closeSync(targetFd);
 	}
@@ -330,7 +348,9 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 			// ENOENT on an ancestor of realTarget after realpathSync is concerning
 			// — the path existed when we validated it but now doesn't. This could
 			// indicate a race or attack. For safety, treat this as an error.
-			throw new Error(`Cannot validate resolved path: ${ancestor} disappeared after realpathSync: ${error instanceof Error ? error.message : String(error)}`);
+			throw new Error(
+				`Cannot validate resolved path: ${ancestor} disappeared after realpathSync: ${error instanceof Error ? error.message : String(error)}`,
+			);
 		}
 		ancestor = path.dirname(ancestor);
 	}
@@ -354,12 +374,13 @@ export function resolveRealContainedPath(baseDir: string, targetPath: string): s
 }
 
 export function resolveContainedRelativePath(baseDir: string, relativePath: string, kind = "path"): string {
-	if (relativePath.includes('\0')) {
+	if (relativePath.includes("\0")) {
 		throw new Error(`Security: path contains null byte: ${kind}`);
 	}
 	const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
 	// Detect Windows absolute paths (C:\, \\server\share) that path.isAbsolute may miss after normalization
 	if (/^[A-Za-z]:/.test(normalized)) throw new Error(`Invalid ${kind}: ${relativePath}`);
-	if (!normalized || normalized.split("/").some((segment) => segment === "..") || path.isAbsolute(normalized)) throw new Error(`Invalid ${kind}: ${relativePath}`);
+	if (!normalized || normalized.split("/").some((segment) => segment === "..") || path.isAbsolute(normalized))
+		throw new Error(`Invalid ${kind}: ${relativePath}`);
 	return resolveContainedPath(baseDir, path.resolve(baseDir, normalized));
 }

package/src/utils/scan-cache.ts

@@ -106,7 +106,14 @@ export class SharedScanCache {
 			if (cached && cached.mtimeMs >= stat.mtimeMs && cached.sizeBytes === stat.size) return cached;
 			const content = fs.readFileSync(filePath, "utf-8");
 			const raw = parseJson ? JSON.parse(content) : content;
-			const entry: ScanEntry = { key, path: filePath, raw, mtimeMs: stat.mtimeMs, sizeBytes: stat.size, loadedAtMs: this.#now() };
+			const entry: ScanEntry = {
+				key,
+				path: filePath,
+				raw,
+				mtimeMs: stat.mtimeMs,
+				sizeBytes: stat.size,
+				loadedAtMs: this.#now(),
+			};
 			this.set(bucket, entry);
 			return entry;
 		} catch {
@@ -134,4 +141,4 @@ export class SharedScanCache {
 }
 
 /** Global shared scan cache instance. */
-export const sharedScanCache = new SharedScanCache();
+export const sharedScanCache = new SharedScanCache();

package/src/utils/session-utils.ts

@@ -14,9 +14,7 @@
  */
 export function assertValidSessionId(id: string): void {
 	if (!id || !/^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/.test(id)) {
-		throw new Error(
-			`Invalid session id: must be non-empty, alphanumeric with '-', '_', '.' and start/end with alphanumeric`,
-		);
+		throw new Error(`Invalid session id: must be non-empty, alphanumeric with '-', '_', '.' and start/end with alphanumeric`);
 	}
 }
 
@@ -79,4 +77,4 @@ export function extractSessionId(ctx: unknown): string | undefined {
 	}
 	if (typeof raw !== "string" || raw.length === 0) return undefined;
 	return raw;
-}
+}

package/src/utils/sleep.ts

@@ -16,7 +16,10 @@ export function sleepSync(ms: number): void {
 		// On Unix, try spawning the `sleep` command to avoid CPU busy-wait.
 		if (process.platform !== "win32" && ms >= 10) {
 			try {
-				execFileSync("sleep", [(ms / 1000).toFixed(3)], { timeout: ms + 1000, stdio: "pipe" });
+				execFileSync("sleep", [(ms / 1000).toFixed(3)], {
+					timeout: ms + 1000,
+					stdio: "pipe",
+				});
 				return;
 			} catch {
 				// sleep command unavailable — fall through to busy-wait
@@ -39,9 +42,13 @@ export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
 	if (signal?.aborted) return Promise.reject(new Error("aborted"));
 	return new Promise<void>((resolve, reject) => {
 		const timer = setTimeout(resolve, ms);
-		signal?.addEventListener("abort", () => {
-			clearTimeout(timer);
-			reject(new Error("aborted"));
-		}, { once: true });
+		signal?.addEventListener(
+			"abort",
+			() => {
+				clearTimeout(timer);
+				reject(new Error("aborted"));
+			},
+			{ once: true },
+		);
 	});
 }

package/src/utils/sse-parser.ts

@@ -12,10 +12,7 @@ const MAX_EVENT_LINES = 1000;
 const MAX_DATA_SIZE = 100000; // 100KB per line
 
 /** Read newline-delimited lines from a text ReadableStream, buffering partial chunks. */
-async function* readLines(
-	stream: ReadableStream<string>,
-	signal?: AbortSignal,
-): AsyncGenerator<string> {
+async function* readLines(stream: ReadableStream<string>, signal?: AbortSignal): AsyncGenerator<string> {
 	const reader = stream.getReader();
 	let buffer = "";
 	try {
@@ -29,9 +26,7 @@ async function* readLines(
 			buffer += value;
 			let idx: number;
 			while ((idx = buffer.indexOf("\n")) !== -1) {
-				const line = buffer.endsWith("\r\n", idx + 1)
-					? buffer.slice(0, idx - 1)
-					: buffer.slice(0, idx);
+				const line = buffer.endsWith("\r\n", idx + 1) ? buffer.slice(0, idx - 1) : buffer.slice(0, idx);
 				yield line;
 				buffer = buffer.slice(idx + 1);
 			}
@@ -42,10 +37,7 @@ async function* readLines(
 }
 
 /** Parse SSE events from a byte stream */
-export async function* readSseEvents(
-	stream: ReadableStream<Uint8Array>,
-	signal?: AbortSignal,
-): AsyncGenerator<ServerSentEvent> {
+export async function* readSseEvents(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<ServerSentEvent> {
 	const textStream = stream.pipeThrough(new TextDecoderStream() as unknown as TransformStream<Uint8Array, string>);
 	let currentEvent: string | null = null;
 	let currentData: string[] = [];
@@ -127,15 +119,11 @@ export async function* readSseEvents(
 }
 
 /** Parse SSE events and yield parsed JSON data objects */
-export async function* readSseJson<T>(
-	stream: ReadableStream<Uint8Array>,
-	signal?: AbortSignal,
-): AsyncGenerator<T> {
+export async function* readSseJson<T>(stream: ReadableStream<Uint8Array>, signal?: AbortSignal): AsyncGenerator<T> {
 	for await (const evt of readSseEvents(stream, signal)) {
 		try {
 			const parsed: T = JSON.parse(evt.data) as T;
 			yield parsed;
-		} catch {
-		}
+		} catch {}
 	}
 }