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

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [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
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "3.5.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.5.1337",
-		"@oh-my-pi/pi-ai": "3.5.1337",
-		"@oh-my-pi/pi-tui": "3.5.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",
@@ -52,6 +52,7 @@
 		"highlight.js": "^11.11.1",
 		"marked": "^15.0.12",
 		"minimatch": "^10.1.1",
+		"nanoid": "^5.1.6",
 		"node-html-parser": "^6.1.13",
 		"smol-toml": "^1.6.0",
 		"strip-ansi": "^7.1.2",

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

@@ -13,6 +13,7 @@ import {
 import { join, resolve } from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent } from "@oh-my-pi/pi-ai";
+import { nanoid } from "nanoid";
 import { getAgentDir as getDefaultAgentDir } from "../config";
 import {
 	type BashExecutionMessage,
@@ -196,11 +197,10 @@ export type ReadonlySessionManager = Pick<
 /** Generate a unique short ID (8 hex chars, collision-checked) */
 function generateId(byId: { has(id: string): boolean }): string {
 	for (let i = 0; i < 100; i++) {
-		const id = crypto.randomUUID().slice(0, 8);
+		const id = nanoid(8);
 		if (!byId.has(id)) return id;
 	}
-	// Fallback to full UUID if somehow we have collisions
-	return crypto.randomUUID();
+	return nanoid(); // fallback to full nanoid
 }
 
 /** Migrate v1 → v2: add id/parentId tree structure. Mutates in place. */
@@ -451,42 +451,108 @@ export function loadEntriesFromFile(filePath: string): FileEntry[] {
 	return entries;
 }
 
-function isValidSessionFile(filePath: string): boolean {
-	try {
-		const fd = openSync(filePath, "r");
-		const buffer = Buffer.alloc(512);
-		const bytesRead = readSync(fd, buffer, 0, 512, 0);
-		closeSync(fd);
-		const firstLine = buffer.toString("utf8", 0, bytesRead).split("\n")[0];
-		if (!firstLine) return false;
-		const header = JSON.parse(firstLine);
-		return header.type === "session" && typeof header.id === "string";
-	} catch {
-		return false;
+/**
+ * Lightweight metadata for a session file, used in session picker UI.
+ * Uses lazy getters to defer string formatting until actually displayed.
+ */
+class RecentSessionInfo {
+	readonly path: string;
+	readonly mtime: number;
+
+	#fullName: string | undefined;
+	#name: string | undefined;
+	#timeAgo: string | undefined;
+
+	constructor(path: string, mtime: number, header: Record<string, unknown>) {
+		this.path = path;
+		this.mtime = mtime;
+
+		// Extract title from session header, falling back to id if title is missing
+		const trystr = (v: unknown) => (typeof v === "string" ? v : undefined);
+		this.#fullName = trystr(header.title) ?? trystr(header.id);
+	}
+
+	/** Full session name from header, or filename without extension as fallback */
+	get fullName(): string {
+		if (this.#fullName) return this.#fullName;
+		this.#fullName = this.path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
+		return this.#fullName;
+	}
+
+	/** Truncated name for display (max 40 chars) */
+	get name(): string {
+		if (this.#name) return this.#name;
+		const fullName = this.fullName;
+		this.#name = fullName.length <= 40 ? fullName : `${fullName.slice(0, 37)}...`;
+		return this.#name;
+	}
+
+	/** Human-readable relative time (e.g., "2 hours ago") */
+	get timeAgo(): string {
+		if (this.#timeAgo) return this.#timeAgo;
+		this.#timeAgo = formatTimeAgo(new Date(this.mtime));
+		return this.#timeAgo;
 	}
 }
 
-/** Exported for testing */
-export function findMostRecentSession(sessionDir: string): string | null {
+/**
+ * Reads all session files from the directory and returns them sorted by mtime (newest first).
+ * Uses low-level file I/O to efficiently read only the first 512 bytes of each file
+ * to extract the JSON header without loading entire session logs into memory.
+ */
+function getSortedSessions(sessionDir: string): RecentSessionInfo[] {
 	try {
-		const files = readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => join(sessionDir, f))
-			.filter(isValidSessionFile)
-			.map((path) => ({ path, mtime: statSync(path).mtime }))
-			.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-
-		return files[0]?.path || null;
+		// Reusable buffer for reading file headers
+		const buf = Buffer.allocUnsafe(512);
+
+		/**
+		 * Reads the first line (JSON header) from an open file descriptor.
+		 * Returns null if the file is empty or doesn't start with valid JSON.
+		 */
+		const readHeader = (fd: number) => {
+			const bytesRead = readSync(fd, buf, 0, 512, 0);
+			if (bytesRead === 0) return null;
+			const sub = buf.subarray(0, bytesRead);
+			// Quick check: first char must be '{' for valid JSON object
+			if (sub.at(0) !== "{".charCodeAt(0)) return null;
+			// Find end of first JSON line
+			const eol = sub.indexOf("}\n");
+			if (eol <= 0) return null;
+			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)
+			.map((f) => {
+				try {
+					if (!f.endsWith(".jsonl")) return null;
+					const path = join(sessionDir, f);
+					const fd = openSync(path, "r");
+					try {
+						const header = readHeader(fd);
+						if (!header) return null;
+						const mtime = statSync(path).mtimeMs;
+						return new RecentSessionInfo(path, mtime, header);
+					} finally {
+						closeSync(fd);
+					}
+				} catch {
+					return null;
+				}
+			})
+			.filter((x) => x !== null)
+			.sort((a, b) => b.mtime - a.mtime); // Sort newest first
 	} catch {
-		return null;
+		return [];
 	}
 }
 
-/** Recent session info for display */
-export interface RecentSessionInfo {
-	name: string;
-	path: string;
-	timeAgo: string;
+/** Exported for testing */
+export function findMostRecentSession(sessionDir: string): string | null {
+	const sessions = getSortedSessions(sessionDir);
+	return sessions[0]?.path || null;
 }
 
 /** Format a time difference as a human-readable string */
@@ -506,41 +572,7 @@ function formatTimeAgo(date: Date): string {
 
 /** Get recent sessions for display in welcome screen */
 export function getRecentSessions(sessionDir: string, limit = 3): RecentSessionInfo[] {
-	try {
-		const files = readdirSync(sessionDir)
-			.filter((f) => f.endsWith(".jsonl"))
-			.map((f) => join(sessionDir, f))
-			.filter(isValidSessionFile)
-			.map((path) => {
-				const stat = statSync(path);
-				// Try to get session title or id from first line
-				let name = path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
-				try {
-					const content = readFileSync(path, "utf-8");
-					const firstLine = content.split("\n")[0];
-					if (firstLine) {
-						const header = JSON.parse(firstLine) as SessionHeader;
-						if (header.type === "session") {
-							// Prefer title over id
-							name = header.title ?? header.id ?? name;
-						}
-					}
-				} catch {
-					// Use filename as fallback
-				}
-				return { path, name, mtime: stat.mtime };
-			})
-			.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-			.slice(0, limit);
-
-		return files.map((f) => ({
-			name: f.name.length > 40 ? `${f.name.slice(0, 37)}...` : f.name,
-			path: f.path,
-			timeAgo: formatTimeAgo(f.mtime),
-		}));
-	} catch {
-		return [];
-	}
+	return getSortedSessions(sessionDir).slice(0, limit);
 }
 
 /**
@@ -588,7 +620,7 @@ export class SessionManager {
 		if (existsSync(this.sessionFile)) {
 			this.fileEntries = loadEntriesFromFile(this.sessionFile);
 			const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
-			this.sessionId = header?.id ?? crypto.randomUUID();
+			this.sessionId = header?.id ?? nanoid();
 			this.sessionTitle = header?.title;
 
 			if (migrateToCurrentVersion(this.fileEntries)) {
@@ -603,7 +635,7 @@ export class SessionManager {
 	}
 
 	newSession(options?: NewSessionOptions): string | undefined {
-		this.sessionId = crypto.randomUUID();
+		this.sessionId = nanoid();
 		const timestamp = new Date().toISOString();
 		const header: SessionHeader = {
 			type: "session",
@@ -676,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"));
 					}
 				}
@@ -1081,7 +1120,7 @@ export class SessionManager {
 		// Filter out LabelEntry from path - we'll recreate them from the resolved map
 		const pathWithoutLabels = path.filter((e) => e.type !== "label");
 
-		const newSessionId = crypto.randomUUID();
+		const newSessionId = nanoid();
 		const timestamp = new Date().toISOString();
 		const fileTimestamp = timestamp.replace(/[:.]/g, "-");
 		const newSessionFile = join(this.getSessionDir(), `${fileTimestamp}_${newSessionId}.jsonl`);