@oh-my-pi/pi-coding-agent 13.14.0 → 13.14.2

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.14.0",
+	"version": "13.14.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.14.0",
-		"@oh-my-pi/pi-agent-core": "13.14.0",
-		"@oh-my-pi/pi-ai": "13.14.0",
-		"@oh-my-pi/pi-natives": "13.14.0",
-		"@oh-my-pi/pi-tui": "13.14.0",
-		"@oh-my-pi/pi-utils": "13.14.0",
+		"@oh-my-pi/omp-stats": "13.14.2",
+		"@oh-my-pi/pi-agent-core": "13.14.2",
+		"@oh-my-pi/pi-ai": "13.14.2",
+		"@oh-my-pi/pi-natives": "13.14.2",
+		"@oh-my-pi/pi-tui": "13.14.2",
+		"@oh-my-pi/pi-utils": "13.14.2",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/exec/bash-executor.ts

@@ -69,11 +69,16 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		// Throttle the streaming preview callback to avoid saturating the
+		// event loop when commands produce massive output (e.g. seq 1 50M).
+		chunkThrottleMs: options?.onChunk ? 50 : 0,
 	});
 
-	let pendingChunks = Promise.resolve();
+	// sink.push() is synchronous — buffer management, counters, and onChunk
+	// all run inline. File writes (artifact path) are handled asynchronously
+	// inside the sink. No promise chain needed.
 	const enqueueChunk = (chunk: string) => {
-		pendingChunks = pendingChunks.then(() => sink.push(chunk)).catch(() => {});
+		sink.push(chunk);
 	};
 
 	if (options?.signal?.aborted) {
@@ -160,8 +165,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 			hardTimeoutDeferred.promise.then(() => ({ kind: "hard-timeout" as const })),
 		]);
 
-		await pendingChunks;
-
 		if (winner.kind === "hard-timeout") {
 			if (shellSession) {
 				resetSession = true;
@@ -215,7 +218,6 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		if (userSignal) {
 			userSignal.removeEventListener("abort", abortHandler);
 		}
-		await pendingChunks;
 		if (resetSession) {
 			shellSessions.delete(sessionKey);
 		}

package/src/modes/components/bash-execution.ts

@@ -6,13 +6,17 @@ import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { Container, ImageProtocol, Loader, Spacer, TERMINAL, Text, type TUI } from "@oh-my-pi/pi-tui";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import { formatTruncationMetaNotice, type TruncationMeta } from "../../tools/output-meta";
-import { getSixelLineMask, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
+import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
 import { DynamicBorder } from "./dynamic-border";
 import { truncateToVisualLines } from "./visual-truncate";
 
 // Preview line limit when not expanded (matches tool execution behavior)
 const PREVIEW_LINES = 20;
+const STREAMING_LINE_CAP = PREVIEW_LINES * 5;
 const MAX_DISPLAY_LINE_CHARS = 4000;
+// Minimum interval between processing incoming chunks for display (ms).
+// Chunks arriving faster than this are accumulated and processed in one batch.
+const CHUNK_THROTTLE_MS = 50;
 
 export class BashExecutionComponent extends Container {
 	#outputLines: string[] = [];
@@ -21,7 +25,10 @@ export class BashExecutionComponent extends Container {
 	#loader: Loader;
 	#truncation?: TruncationMeta;
 	#expanded = false;
+	#displayDirty = false;
+	#chunkGate = false;
 	#contentContainer: Container;
+	#headerText: Text;
 
 	constructor(
 		private readonly command: string,
@@ -45,8 +52,8 @@ export class BashExecutionComponent extends Container {
 		this.addChild(this.#contentContainer);
 
 		// Command header
-		const header = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
-		this.#contentContainer.addChild(header);
+		this.#headerText = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
+		this.#contentContainer.addChild(this.#headerText);
 
 		// Loader
 		this.#loader = new Loader(
@@ -72,14 +79,22 @@ export class BashExecutionComponent extends Container {
 
 	override invalidate(): void {
 		super.invalidate();
+		this.#displayDirty = false;
 		this.#updateDisplay();
 	}
 
 	appendOutput(chunk: string): void {
-		const clean = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
-
-		// Append to output lines
-		const incomingLines = clean.split("\n");
+		// During high-throughput output (e.g. seq 1 500M), processing every
+		// chunk would saturate the event loop. Instead, accept one chunk per
+		// throttle window and drop the rest — the OutputSink captures everything
+		// for the artifact, and setComplete() replaces with the final output.
+		if (this.#chunkGate) return;
+		this.#chunkGate = true;
+		setTimeout(() => {
+			this.#chunkGate = false;
+		}, CHUNK_THROTTLE_MS);
+
+		const incomingLines = chunk.split("\n");
 		if (this.#outputLines.length > 0 && incomingLines.length > 0) {
 			const lastIndex = this.#outputLines.length - 1;
 			const mergedLines = [`${this.#outputLines[lastIndex]}${incomingLines[0]}`, ...incomingLines.slice(1)];
@@ -90,7 +105,12 @@ export class BashExecutionComponent extends Container {
 			this.#outputLines.push(...this.#clampLinesPreservingSixel(incomingLines));
 		}
 
-		this.#updateDisplay();
+		// Cap stored lines during streaming to avoid unbounded memory growth
+		if (this.#outputLines.length > STREAMING_LINE_CAP) {
+			this.#outputLines = this.#outputLines.slice(-STREAMING_LINE_CAP);
+		}
+
+		this.#displayDirty = true;
 	}
 
 	setComplete(
@@ -115,6 +135,14 @@ export class BashExecutionComponent extends Container {
 		this.#updateDisplay();
 	}
 
+	override render(width: number): string[] {
+		if (this.#displayDirty) {
+			this.#displayDirty = false;
+			this.#updateDisplay();
+		}
+		return super.render(width);
+	}
+
 	#updateDisplay(): void {
 		const availableLines = this.#outputLines;
 
@@ -122,15 +150,16 @@ export class BashExecutionComponent extends Container {
 		const previewLogicalLines = availableLines.slice(-PREVIEW_LINES);
 		const hiddenLineCount = availableLines.length - previewLogicalLines.length;
 		const sixelLineMask =
-			TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(availableLines) : undefined;
+			TERMINAL.imageProtocol === ImageProtocol.Sixel && isSixelPassthroughEnabled()
+				? getSixelLineMask(availableLines)
+				: undefined;
 		const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
 
 		// Rebuild content container
 		this.#contentContainer.clear();
 
 		// Command header
-		const header = new Text(theme.fg("bashMode", theme.bold(`$ ${this.command}`)), 1, 0);
-		this.#contentContainer.addChild(header);
+		this.#contentContainer.addChild(this.#headerText);
 
 		// Output
 		if (availableLines.length > 0) {

package/src/modes/components/python-execution.ts

@@ -72,9 +72,8 @@ export class PythonExecutionComponent extends Container {
 	}
 
 	appendOutput(chunk: string): void {
-		const clean = sanitizeText(chunk);
-
-		const newLines = clean.split("\n").map(line => this.#clampDisplayLine(line));
+		// Chunk is pre-sanitized by OutputSink.push() — no need to sanitize again.
+		const newLines = chunk.split("\n").map(line => this.#clampDisplayLine(line));
 		if (this.#outputLines.length > 0 && newLines.length > 0) {
 			this.#outputLines[this.#outputLines.length - 1] = this.#clampDisplayLine(
 				`${this.#outputLines[this.#outputLines.length - 1]}${newLines[0]}`,

package/src/modes/components/tool-execution.ts

@@ -105,17 +105,16 @@ export class ToolExecutionComponent extends Container {
 	// Cached converted images for Kitty protocol (which requires PNG), keyed by index
 	#convertedImages: Map<number, { data: string; mimeType: string }> = new Map();
 	// Spinner animation for partial task results
-	#spinnerFrame = 0;
+	#spinnerFrame?: number;
 	#spinnerInterval?: NodeJS.Timeout;
 	// Track if args are still being streamed (for edit/write spinner)
 	#argsComplete = false;
 	#renderState: {
-		spinnerFrame: number;
+		spinnerFrame?: number;
 		expanded: boolean;
 		isPartial: boolean;
 		renderContext?: Record<string, unknown>;
 	} = {
-		spinnerFrame: 0,
 		expanded: false,
 		isPartial: true,
 	};
@@ -328,10 +327,9 @@ export class ToolExecutionComponent extends Container {
 			this.#spinnerInterval = setInterval(() => {
 				const frameCount = theme.spinnerFrames.length;
 				if (frameCount === 0) return;
-				this.#spinnerFrame = (this.#spinnerFrame + 1) % frameCount;
+				this.#spinnerFrame = ((this.#spinnerFrame ?? -1) + 1) % frameCount;
 				this.#renderState.spinnerFrame = this.#spinnerFrame;
 				this.#ui.requestRender();
-				// NO updateDisplay() — existing component closures read from renderState
 			}, 80);
 		} else if (!needsSpinner && this.#spinnerInterval) {
 			clearInterval(this.#spinnerInterval);
@@ -346,6 +344,7 @@ export class ToolExecutionComponent extends Container {
 		if (this.#spinnerInterval) {
 			clearInterval(this.#spinnerInterval);
 			this.#spinnerInterval = undefined;
+			this.#spinnerFrame = undefined;
 		}
 	}
 

package/src/modes/controllers/command-controller.ts

@@ -690,7 +690,6 @@ export class CommandController {
 				chunk => {
 					if (this.ctx.bashComponent) {
 						this.ctx.bashComponent.appendOutput(chunk);
-						this.ctx.ui.requestRender();
 					}
 				},
 				{ excludeFromContext },
@@ -732,7 +731,6 @@ export class CommandController {
 				chunk => {
 					if (this.ctx.pythonComponent) {
 						this.ctx.pythonComponent.appendOutput(chunk);
-						this.ctx.ui.requestRender();
 					}
 				},
 				{ excludeFromContext },

package/src/session/streaming-output.ts

@@ -32,6 +32,8 @@ export interface OutputSinkOptions {
 	artifactId?: string;
 	spillThreshold?: number;
 	onChunk?: (chunk: string) => void;
+	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
+	chunkThrottleMs?: number;
 }
 
 export interface TruncationResult {
@@ -521,6 +523,7 @@ export class OutputSink {
 	#totalBytes = 0;
 	#sawData = false;
 	#truncated = false;
+	#lastChunkTime = 0;
 
 	#file?: {
 		path: string;
@@ -528,22 +531,46 @@ export class OutputSink {
 		sink: Bun.FileSink;
 	};
 
+	// Queue of chunks waiting for the file sink to be created.
+	#pendingFileWrites?: string[];
+	#fileReady = false;
+
 	readonly #artifactPath?: string;
 	readonly #artifactId?: string;
 	readonly #spillThreshold: number;
 	readonly #onChunk?: (chunk: string) => void;
+	readonly #chunkThrottleMs: number;
 
 	constructor(options?: OutputSinkOptions) {
-		const { artifactPath, artifactId, spillThreshold = DEFAULT_MAX_BYTES, onChunk } = options ?? {};
+		const {
+			artifactPath,
+			artifactId,
+			spillThreshold = DEFAULT_MAX_BYTES,
+			onChunk,
+			chunkThrottleMs = 0,
+		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
 		this.#spillThreshold = spillThreshold;
 		this.#onChunk = onChunk;
+		this.#chunkThrottleMs = chunkThrottleMs;
 	}
 
-	async push(chunk: string): Promise<void> {
+	/**
+	 * Push a chunk of output. The buffer management and onChunk callback run
+	 * synchronously. File sink writes are deferred and serialized internally.
+	 */
+	push(chunk: string): void {
 		chunk = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
-		this.#onChunk?.(chunk);
+
+		// Throttled onChunk: only call the callback when enough time has passed.
+		if (this.#onChunk) {
+			const now = Date.now();
+			if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
+				this.#lastChunkTime = now;
+				this.#onChunk(chunk);
+			}
+		}
 
 		const dataBytes = Buffer.byteLength(chunk, "utf-8");
 		this.#totalBytes += dataBytes;
@@ -556,10 +583,9 @@ export class OutputSink {
 		const threshold = this.#spillThreshold;
 		const willOverflow = this.#bufferBytes + dataBytes > threshold;
 
-		// Write to file if already spilling or about to overflow
-		if (this.#file != null || willOverflow) {
-			const sink = await this.#ensureFileSink();
-			await sink?.write(chunk);
+		// Write to artifact file if configured and past the threshold
+		if (this.#artifactPath && (this.#file != null || willOverflow)) {
+			this.#writeToFile(chunk);
 		}
 
 		if (!willOverflow) {
@@ -589,14 +615,64 @@ export class OutputSink {
 		if (this.#file) this.#truncated = true;
 	}
 
+	/**
+	 * Write a chunk to the artifact file. Handles the async file sink creation
+	 * by queuing writes until the sink is ready, then draining synchronously.
+	 */
+	#writeToFile(chunk: string): void {
+		if (this.#fileReady && this.#file) {
+			// Fast path: file sink exists, write synchronously
+			this.#file.sink.write(chunk);
+			return;
+		}
+		// File sink not yet created — queue this chunk and kick off creation
+		if (!this.#pendingFileWrites) {
+			this.#pendingFileWrites = [chunk];
+			void this.#createFileSink();
+		} else {
+			this.#pendingFileWrites.push(chunk);
+		}
+	}
+
+	async #createFileSink(): Promise<void> {
+		if (!this.#artifactPath || this.#fileReady) return;
+		try {
+			const sink = Bun.file(this.#artifactPath).writer();
+			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
+
+			// Flush existing buffer to file BEFORE it gets trimmed further.
+			if (this.#buffer.length > 0) {
+				sink.write(this.#buffer);
+			}
+
+			// Drain any chunks that arrived while the sink was being created
+			if (this.#pendingFileWrites) {
+				for (const pending of this.#pendingFileWrites) {
+					sink.write(pending);
+				}
+				this.#pendingFileWrites = undefined;
+			}
+
+			this.#fileReady = true;
+		} catch {
+			try {
+				await this.#file?.sink?.end();
+			} catch {
+				/* ignore */
+			}
+			this.#file = undefined;
+			this.#pendingFileWrites = undefined;
+		}
+	}
+
 	createInput(): WritableStream<Uint8Array | string> {
 		const dec = new TextDecoder("utf-8", { ignoreBOM: true });
-		const finalize = async () => {
-			await this.push(dec.decode());
+		const finalize = () => {
+			this.push(dec.decode());
 		};
 		return new WritableStream({
-			write: async chunk => {
-				await this.push(typeof chunk === "string" ? chunk : dec.decode(chunk, { stream: true }));
+			write: chunk => {
+				this.push(typeof chunk === "string" ? chunk : dec.decode(chunk, { stream: true }));
 			},
 			close: finalize,
 			abort: finalize,
@@ -620,32 +696,6 @@ export class OutputSink {
 			artifactId: this.#file?.artifactId,
 		};
 	}
-
-	// -- private ---------------------------------------------------------------
-
-	async #ensureFileSink(): Promise<Bun.FileSink | null> {
-		if (!this.#artifactPath) return null;
-		if (this.#file) return this.#file.sink;
-
-		try {
-			const sink = Bun.file(this.#artifactPath).writer();
-			this.#file = { path: this.#artifactPath, artifactId: this.#artifactId, sink };
-
-			// Flush existing buffer to file BEFORE it gets trimmed further.
-			if (this.#buffer.length > 0) {
-				await sink.write(this.#buffer);
-			}
-			return sink;
-		} catch {
-			try {
-				await this.#file?.sink?.end();
-			} catch {
-				/* ignore */
-			}
-			this.#file = undefined;
-			return null;
-		}
-	}
 }
 
 // =============================================================================

package/src/tools/bash-interactive.ts

@@ -295,7 +295,6 @@ export async function runInteractiveBashPty(
 	},
 ): Promise<BashInteractiveResult> {
 	const sink = new OutputSink({ artifactPath: options.artifactPath, artifactId: options.artifactId });
-	let pendingChunks = Promise.resolve();
 	const result = await ui.custom<BashInteractiveResult>(
 		(tui, uiTheme, _keybindings, done) => {
 			const session = new PtySession();
@@ -309,7 +308,6 @@ export async function runInteractiveBashPty(
 				tui.requestRender();
 				void (async () => {
 					await component.flushOutput();
-					await pendingChunks;
 					const summary = await sink.dump();
 					done({
 						exitCode: run.exitCode,
@@ -362,15 +360,13 @@ export async function runInteractiveBashPty(
 						if (finished || err || !chunk) return;
 						component.appendOutput(chunk);
 						const normalizedChunk = normalizeCaptureChunk(chunk);
-						pendingChunks = pendingChunks.then(() => sink.push(normalizedChunk)).catch(() => {});
+						sink.push(normalizedChunk);
 						tui.requestRender();
 					},
 				)
 				.then(finalize)
 				.catch(error => {
-					pendingChunks = pendingChunks
-						.then(() => sink.push(`PTY error: ${error instanceof Error ? error.message : String(error)}\n`))
-						.catch(() => {});
+					sink.push(`PTY error: ${error instanceof Error ? error.message : String(error)}\n`);
 					finalize({ exitCode: undefined, cancelled: false, timedOut: false });
 				});
 			return component;

package/src/tools/python.ts

@@ -289,8 +289,8 @@ export class PythonTool implements AgentTool<typeof pythonSchema> {
 				const executorOptions: PythonExecutorOptions = {
 					...baseExecutorOptions,
 					reset: isFirstCell ? reset : false,
-					onChunk: async chunk => {
-						await outputSink!.push(chunk);
+					onChunk: chunk => {
+						outputSink!.push(chunk);
 					},
 				};