@oh-my-pi/pi-coding-agent 3.6.1337 → 3.8.1337

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [3.8.1337] - 2026-01-04
+### Added
+
+- Added automatic browser opening after exporting session to HTML
+- Added automatic browser opening after sharing session as a Gist
+
+### Fixed
+
+- Fixed session titles not persisting to file when set before first flush
+
+## [3.7.1337] - 2026-01-04
+### Added
+
+- Added `EditMatchError` class for structured error handling in edit operations
+- Added `utils` module export with `once` and `untilAborted` helper functions
+- Added in-memory LSP content sync via `syncContent` and `notifySaved` client methods
+
+### Changed
+
+- Refactored LSP integration to use writethrough callbacks for edit and write tools, improving performance by syncing content in-memory before disk writes
+- Simplified FileDiagnosticsResult interface with renamed fields: `diagnostics` → `messages`, `hasErrors` → `errored`, `serverName` → `server`
+- Session title generation now triggers before sending the first message rather than after agent work begins
+
+### Fixed
+
+- Fixed potential text decoding issues in bash executor by using streaming TextDecoder instead of Buffer.toString()
+
 ## [3.6.1337] - 2026-01-03
 
 ## [3.5.1337] - 2026-01-03

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.6.1337",
+	"version": "3.8.1337",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,9 +39,9 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "3.6.1337",
-		"@oh-my-pi/pi-ai": "3.6.1337",
-		"@oh-my-pi/pi-tui": "3.6.1337",
+		"@oh-my-pi/pi-agent-core": "3.8.1337",
+		"@oh-my-pi/pi-ai": "3.8.1337",
+		"@oh-my-pi/pi-tui": "3.8.1337",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",
 		"chalk": "^5.5.0",

package/src/core/bash-executor.ts

@@ -14,6 +14,7 @@ import stripAnsi from "strip-ansi";
 import { getShellConfig, killProcessTree, sanitizeBinaryOutput } from "../utils/shell";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
 import { DEFAULT_MAX_BYTES, truncateTail } from "./tools/truncate";
+import { ScopeSignal } from "./utils";
 
 // ============================================================================
 // Types
@@ -47,6 +48,70 @@ export interface BashResult {
 // Implementation
 // ============================================================================
 
+function createSanitizer(): TransformStream<Uint8Array, string> {
+	const decoder = new TextDecoder();
+	return new TransformStream({
+		transform(chunk, controller) {
+			const text = sanitizeBinaryOutput(stripAnsi(decoder.decode(chunk, { stream: true }))).replace(/\r/g, "");
+			controller.enqueue(text);
+		},
+	});
+}
+
+function createOutputSink(
+	spillThreshold: number,
+	maxBuffer: number,
+	onChunk?: (text: string) => void,
+): WritableStream<string> & {
+	dump: (annotation?: string) => { output: string; truncated: boolean; fullOutputPath?: string };
+} {
+	const chunks: string[] = [];
+	let chunkBytes = 0;
+	let totalBytes = 0;
+	let fullOutputPath: string | undefined;
+	let fullOutputStream: WriteStream | undefined;
+
+	const sink = new WritableStream<string>({
+		write(text) {
+			totalBytes += text.length;
+
+			// Spill to temp file if needed
+			if (totalBytes > spillThreshold && !fullOutputPath) {
+				fullOutputPath = join(tmpdir(), `omp-${crypto.randomUUID()}.buffer`);
+				const ts = createWriteStream(fullOutputPath);
+				chunks.forEach((c) => {
+					ts.write(c);
+				});
+				fullOutputStream = ts;
+			}
+			fullOutputStream?.write(text);
+
+			// Rolling buffer
+			chunks.push(text);
+			chunkBytes += text.length;
+			while (chunkBytes > maxBuffer && chunks.length > 1) {
+				chunkBytes -= chunks.shift()!.length;
+			}
+
+			onChunk?.(text);
+		},
+		close() {
+			fullOutputStream?.end();
+		},
+	});
+
+	return Object.assign(sink, {
+		dump(annotation?: string) {
+			if (annotation) {
+				chunks.push(`\n\n${annotation}`);
+			}
+			const full = chunks.join("");
+			const { content, truncated } = truncateTail(full);
+			return { output: truncated ? content : full, truncated, fullOutputPath: fullOutputPath };
+		},
+	});
+}
+
 /**
  * Execute a bash command with optional streaming and cancellation support.
  *
@@ -72,165 +137,61 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
 	const finalCommand = `${snapshotPrefix}${prefixedCommand}`;
 
-	return new Promise((resolve, reject) => {
-		const child: Subprocess = Bun.spawn([shell, ...args, finalCommand], {
-			cwd: options?.cwd,
-			stdin: "ignore",
-			stdout: "pipe",
-			stderr: "pipe",
-			env,
-		});
-
-		// Track sanitized output for truncation
-		const outputChunks: string[] = [];
-		let outputBytes = 0;
-		const maxOutputBytes = DEFAULT_MAX_BYTES * 2;
-
-		// Temp file for large output
-		let tempFilePath: string | undefined;
-		let tempFileStream: WriteStream | undefined;
-		let totalBytes = 0;
-		let timedOut = false;
-
-		// Handle abort signal and timeout
-		const abortHandler = () => {
-			killProcessTree(child.pid);
-		};
-
-		// Set up timeout if specified
-		let timeoutHandle: Timer | undefined;
-		if (options?.timeout && options.timeout > 0) {
-			timeoutHandle = setTimeout(() => {
-				timedOut = true;
-				abortHandler();
-			}, options.timeout);
-		}
+	using signal = new ScopeSignal(options);
 
-		if (options?.signal) {
-			if (options.signal.aborted) {
-				// Already aborted, don't even start
-				child.kill();
-				if (timeoutHandle) clearTimeout(timeoutHandle);
-				resolve({
-					output: "",
-					exitCode: undefined,
-					cancelled: true,
-					truncated: false,
-				});
-				return;
-			}
-			options.signal.addEventListener("abort", abortHandler, { once: true });
-		}
-
-		const handleData = (data: Buffer) => {
-			totalBytes += data.length;
-
-			// Sanitize once at the source: strip ANSI, replace binary garbage, normalize newlines
-			const text = sanitizeBinaryOutput(stripAnsi(data.toString())).replace(/\r/g, "");
-
-			// Start writing to temp file if exceeds threshold
-			if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
-				const randomId = crypto.getRandomValues(new Uint8Array(8));
-				const id = Array.from(randomId, (b) => b.toString(16).padStart(2, "0")).join("");
-				tempFilePath = join(tmpdir(), `omp-bash-${id}.log`);
-				tempFileStream = createWriteStream(tempFilePath);
-				// Write already-buffered chunks to temp file
-				for (const chunk of outputChunks) {
-					tempFileStream.write(chunk);
-				}
-			}
+	const child: Subprocess = Bun.spawn([shell, ...args, finalCommand], {
+		cwd: options?.cwd,
+		stdin: "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+		env,
+	});
 
-			if (tempFileStream) {
-				tempFileStream.write(text);
-			}
+	signal.catch(() => {
+		killProcessTree(child.pid);
+	});
 
-			// Keep rolling buffer of sanitized text
-			outputChunks.push(text);
-			outputBytes += text.length;
-			while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
-				const removed = outputChunks.shift()!;
-				outputBytes -= removed.length;
-			}
+	const sink = createOutputSink(DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES * 2, options?.onChunk);
 
-			// Stream to callback if provided
-			if (options?.onChunk) {
-				options.onChunk(text);
-			}
-		};
-
-		// Read streams asynchronously
-		(async () => {
+	const writer = sink.getWriter();
+	try {
+		async function pumpStream(readable: ReadableStream<Uint8Array>) {
+			const reader = readable.pipeThrough(createSanitizer()).getReader();
 			try {
-				const stdoutReader = (child.stdout as ReadableStream<Uint8Array>).getReader();
-				const stderrReader = (child.stderr as ReadableStream<Uint8Array>).getReader();
-
-				await Promise.all([
-					(async () => {
-						while (true) {
-							const { done, value } = await stdoutReader.read();
-							if (done) break;
-							handleData(Buffer.from(value));
-						}
-					})(),
-					(async () => {
-						while (true) {
-							const { done, value } = await stderrReader.read();
-							if (done) break;
-							handleData(Buffer.from(value));
-						}
-					})(),
-				]);
-
-				const exitCode = await child.exited;
-
-				// Clean up
-				if (timeoutHandle) clearTimeout(timeoutHandle);
-				if (options?.signal) {
-					options.signal.removeEventListener("abort", abortHandler);
-				}
-				if (tempFileStream) {
-					tempFileStream.end();
-				}
-
-				// Combine buffered chunks for truncation (already sanitized)
-				const fullOutput = outputChunks.join("");
-				const truncationResult = truncateTail(fullOutput);
-
-				// Handle timeout
-				if (timedOut) {
-					const timeoutSecs = Math.round((options?.timeout || 0) / 1000);
-					resolve({
-						output: `${fullOutput}\n\nCommand timed out after ${timeoutSecs} seconds`,
-						exitCode: undefined,
-						cancelled: true,
-						truncated: truncationResult.truncated,
-						fullOutputPath: tempFilePath,
-					});
-					return;
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					await writer.write(value);
 				}
-
-				// Non-zero exit codes or signal-killed processes are considered cancelled if killed via signal
-				const cancelled = exitCode === null || (exitCode !== 0 && (options?.signal?.aborted ?? false));
-
-				resolve({
-					output: truncationResult.truncated ? truncationResult.content : fullOutput,
-					exitCode: cancelled ? undefined : exitCode,
-					cancelled,
-					truncated: truncationResult.truncated,
-					fullOutputPath: tempFilePath,
-				});
-			} catch (err) {
-				// Clean up
-				if (timeoutHandle) clearTimeout(timeoutHandle);
-				if (options?.signal) {
-					options.signal.removeEventListener("abort", abortHandler);
-				}
-				if (tempFileStream) {
-					tempFileStream.end();
-				}
-
-				reject(err);
+			} finally {
+				reader.releaseLock();
 			}
-		})();
-	});
+		}
+		await Promise.all([
+			pumpStream(child.stdout as ReadableStream<Uint8Array>),
+			pumpStream(child.stderr as ReadableStream<Uint8Array>),
+		]);
+	} finally {
+		await writer.close();
+	}
+
+	// Non-zero exit codes or signal-killed processes are considered cancelled if killed via signal
+	const exitCode = await child.exited;
+
+	const cancelled = exitCode === null || (exitCode !== 0 && (options?.signal?.aborted ?? false));
+
+	if (signal.timedOut()) {
+		const secs = Math.round(options!.timeout! / 1000);
+		return {
+			exitCode: undefined,
+			cancelled: true,
+			...sink.dump(`Command timed out after ${secs} seconds`),
+		};
+	}
+
+	return {
+		exitCode: cancelled ? undefined : exitCode,
+		cancelled,
+		...sink.dump(),
+	};
 }

package/src/core/index.ts

@@ -49,3 +49,5 @@ export {
 	type MCPToolsLoadResult,
 	type MCPTransport,
 } from "./mcp/index";
+
+export * as utils from "./utils";

package/src/core/session-manager.ts

@@ -518,7 +518,10 @@ function getSortedSessions(sessionDir: string): RecentSessionInfo[] {
 			// Find end of first JSON line
 			const eol = sub.indexOf("}\n");
 			if (eol <= 0) return null;
-			return JSON.parse(sub.toString("utf8", 0, eol + 1));
+			const header = JSON.parse(sub.toString("utf8", 0, eol + 1));
+			// Validate session header
+			if (header.type !== "session" || typeof header.id !== "string") return null;
+			return header;
 		};
 
 		return readdirSync(sessionDir)
@@ -705,16 +708,23 @@ export class SessionManager {
 
 	setSessionTitle(title: string): void {
 		this.sessionTitle = title;
-		// Update the session file header with the title
+
+		// Update the in-memory header (so first flush includes title)
+		const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
+		if (header) {
+			header.title = title;
+		}
+
+		// Update the session file header with the title (if already flushed)
 		if (this.persist && this.sessionFile && existsSync(this.sessionFile)) {
 			try {
 				const content = readFileSync(this.sessionFile, "utf-8");
 				const lines = content.split("\n");
 				if (lines.length > 0) {
-					const header = JSON.parse(lines[0]) as SessionHeader;
-					if (header.type === "session") {
-						header.title = title;
-						lines[0] = JSON.stringify(header);
+					const fileHeader = JSON.parse(lines[0]) as SessionHeader;
+					if (fileHeader.type === "session") {
+						fileHeader.title = title;
+						lines[0] = JSON.stringify(fileHeader);
 						writeFileSync(this.sessionFile, lines.join("\n"));
 					}
 				}

package/src/core/tools/edit-diff.ts

@@ -249,40 +249,52 @@ function findFirstDifferentLine(oldLines: string[], newLines: string[]): { oldLi
 	return { oldLine: oldLines[0] ?? "", newLine: newLines[0] ?? "" };
 }
 
-export function formatEditMatchError(
-	path: string,
-	normalizedOldText: string,
-	closest: EditMatch | undefined,
-	options: { allowFuzzy: boolean; similarityThreshold: number; fuzzyMatches?: number },
-): string {
-	if (!closest) {
-		return options.allowFuzzy
-			? `Could not find a close enough match in ${path}.`
-			: `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`;
+export class EditMatchError extends Error {
+	constructor(
+		public readonly path: string,
+		public readonly normalizedOldText: string,
+		public readonly closest: EditMatch | undefined,
+		public readonly options: { allowFuzzy: boolean; similarityThreshold: number; fuzzyMatches?: number },
+	) {
+		super(EditMatchError.formatMessage(path, normalizedOldText, closest, options));
+		this.name = "EditMatchError";
 	}
 
-	const similarity = Math.round(closest.confidence * 100);
-	const oldLines = normalizedOldText.split("\n");
-	const actualLines = closest.actualText.split("\n");
-	const { oldLine, newLine } = findFirstDifferentLine(oldLines, actualLines);
-	const thresholdPercent = Math.round(options.similarityThreshold * 100);
-
-	const hint = options.allowFuzzy
-		? options.fuzzyMatches && options.fuzzyMatches > 1
-			? `Found ${options.fuzzyMatches} high-confidence matches. Provide more context to make it unique.`
-			: `Closest match was below the ${thresholdPercent}% similarity threshold.`
-		: "Fuzzy matching is disabled. Enable 'Edit fuzzy match' in settings to accept high-confidence matches.";
-
-	return [
-		options.allowFuzzy
-			? `Could not find a close enough match in ${path}.`
-			: `Could not find the exact text in ${path}.`,
-		``,
-		`Closest match (${similarity}% similar) at line ${closest.startLine}:`,
-		`  - ${oldLine}`,
-		`  + ${newLine}`,
-		hint,
-	].join("\n");
+	static formatMessage(
+		path: string,
+		normalizedOldText: string,
+		closest: EditMatch | undefined,
+		options: { allowFuzzy: boolean; similarityThreshold: number; fuzzyMatches?: number },
+	): string {
+		if (!closest) {
+			return options.allowFuzzy
+				? `Could not find a close enough match in ${path}.`
+				: `Could not find the exact text in ${path}. The old text must match exactly including all whitespace and newlines.`;
+		}
+
+		const similarity = Math.round(closest.confidence * 100);
+		const oldLines = normalizedOldText.split("\n");
+		const actualLines = closest.actualText.split("\n");
+		const { oldLine, newLine } = findFirstDifferentLine(oldLines, actualLines);
+		const thresholdPercent = Math.round(options.similarityThreshold * 100);
+
+		const hint = options.allowFuzzy
+			? options.fuzzyMatches && options.fuzzyMatches > 1
+				? `Found ${options.fuzzyMatches} high-confidence matches. Provide more context to make it unique.`
+				: `Closest match was below the ${thresholdPercent}% similarity threshold.`
+			: "Fuzzy matching is disabled. Enable 'Edit fuzzy match' in settings to accept high-confidence matches.";
+
+		return [
+			options.allowFuzzy
+				? `Could not find a close enough match in ${path}.`
+				: `Could not find the exact text in ${path}.`,
+			``,
+			`Closest match (${similarity}% similar) at line ${closest.startLine}:`,
+			`  - ${oldLine}`,
+			`  + ${newLine}`,
+			hint,
+		].join("\n");
+	}
 }
 
 /**
@@ -444,7 +456,7 @@ export async function computeEditDiff(
 
 		if (!matchOutcome.match) {
 			return {
-				error: formatEditMatchError(path, normalizedOldText, matchOutcome.closest, {
+				error: EditMatchError.formatMessage(path, normalizedOldText, matchOutcome.closest, {
 					allowFuzzy: fuzzy,
 					similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
 					fuzzyMatches: matchOutcome.fuzzyMatches,