@oh-my-pi/pi-coding-agent 9.7.0 → 9.8.0

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## [Unreleased]
 
+## [9.8.0] - 2026-02-01
+### Breaking Changes
+
+- Removed persistent shell session support; bash execution now uses native bindings via brush-core for improved reliability
+
+### Added
+
+- Added `sessionKey` option to bash executor to isolate shell sessions per agent instance
+- Added shell snapshot support for bash execution to preserve shell state across commands
+- Added `onChunk` callback support for streaming command output in real-time
+
+### Changed
+
+- Refactored bash executor to queue output chunks asynchronously for improved reliability
+- Updated bash executor to pass environment variables separately as `sessionEnv` to native bindings
+- Migrated system information collection to use native bindings from brush-core instead of shell command execution
+- Updated CPU information to report core count alongside model name
+- Simplified OS version reporting to use Node.js built-in APIs
+- Migrated bash command execution from ptree-based persistent sessions to native shell bindings with streaming support
+- Simplified bash executor to use brush-core native API instead of managing long-lived shell processes
+- Routed clipboard copy and image paste through native arboard bindings instead of shell commands
+- Embedded native addon payload for compiled binaries and extract to `~/.omp/natives/<version>` on first run
+
+### Removed
+
+- Removed shell configuration from environment information display
+- Removed `shell-session.ts` module providing persistent shell session management
+- Removed shell session test suite for persistent execution patterns
+
 ## [9.6.2] - 2026-02-01
 ### Changed
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "9.7.0",
+	"version": "9.8.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -74,17 +74,17 @@
 	"scripts": {
 		"check": "tsgo -p tsconfig.json",
 		"format-prompts": "bun scripts/format-prompts.ts",
-		"build:binary": "cd ../.. && bun build --compile --define OMP_COMPILED=true --root . ./packages/coding-agent/src/cli.ts --outfile packages/coding-agent/dist/omp",
+		"build:binary": "cd ../.. && bun --cwd=packages/natives run embed:native && bun build --compile --define OMP_COMPILED=true --root . ./packages/coding-agent/src/cli.ts --outfile packages/coding-agent/dist/omp && bun --cwd=packages/natives run embed:native --reset",
 		"generate-template": "bun scripts/generate-template.ts",
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@oh-my-pi/omp-stats": "9.7.0",
-		"@oh-my-pi/pi-agent-core": "9.7.0",
-		"@oh-my-pi/pi-ai": "9.7.0",
-		"@oh-my-pi/pi-natives": "9.7.0",
-		"@oh-my-pi/pi-tui": "9.7.0",
-		"@oh-my-pi/pi-utils": "9.7.0",
+		"@oh-my-pi/omp-stats": "9.8.0",
+		"@oh-my-pi/pi-agent-core": "9.8.0",
+		"@oh-my-pi/pi-ai": "9.8.0",
+		"@oh-my-pi/pi-natives": "9.8.0",
+		"@oh-my-pi/pi-tui": "9.8.0",
+		"@oh-my-pi/pi-utils": "9.8.0",
 		"@openai/agents": "^0.4.4",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",

package/src/exec/bash-executor.ts

@@ -1,19 +1,20 @@
 /**
  * Bash command execution with streaming support and cancellation.
  *
- * Provides unified bash execution for AgentSession.executeBash() and direct calls.
+ * Uses brush-core via native bindings for shell execution.
  */
-import { Exception, ptree } from "@oh-my-pi/pi-utils";
+import { Shell } from "@oh-my-pi/pi-natives";
 import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
-import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
-import { executeShellCommand } from "./shell-session";
+import { getOrCreateSnapshot } from "../utils/shell-snapshot";
 
 export interface BashExecutorOptions {
 	cwd?: string;
 	timeout?: number;
 	onChunk?: (chunk: string) => void;
 	signal?: AbortSignal;
+	/** Session key suffix to isolate shell sessions per agent */
+	sessionKey?: string;
 	/** Additional environment variables to inject */
 	env?: Record<string, string>;
 	/** Artifact path/id for full output storage */
@@ -33,116 +34,114 @@ export interface BashResult {
 	artifactId?: string;
 }
 
+const shellSessions = new Map<string, Shell>();
+
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
 	const settings = await Settings.init();
-	const { shell, args, env, prefix } = settings.getShellConfig();
-	const snapshotPath = await getOrCreateSnapshot(shell, env);
-
-	if (shouldUsePersistentShell(settings.get("bash.persistentShell"))) {
-		return await executeShellCommand({ shell, env, prefix, snapshotPath }, command, {
-			cwd: options?.cwd,
-			timeout: options?.timeout,
-			signal: options?.signal,
-			onChunk: options?.onChunk,
-			env: options?.env,
-			artifactPath: options?.artifactPath,
-			artifactId: options?.artifactId,
-		});
-	}
-
-	return await executeBashOnce(command, options, { shell, args, env, prefix, snapshotPath });
-}
-
-/**
- * Determine whether to use persistent shell sessions.
- * Priority: OMP_SHELL_PERSIST env var > settings > default (false)
- */
-function shouldUsePersistentShell(settingValue: boolean): boolean {
-	// Env var takes precedence (for debugging/override)
-	const flag = parseEnvFlag(process.env.OMP_SHELL_PERSIST);
-	if (flag !== undefined) return flag;
-	// Windows never uses persistent shell (too unreliable)
-	if (process.platform === "win32") return false;
-	// Use setting value (defaults to false)
-	return settingValue;
-}
-
-function parseEnvFlag(value: string | undefined): boolean | undefined {
-	if (!value) return undefined;
-	const normalized = value.toLowerCase();
-	if (["1", "true", "yes", "on"].includes(normalized)) return true;
-	if (["0", "false", "no", "off"].includes(normalized)) return false;
-	return undefined;
-}
+	const { shell, env: shellEnv, prefix } = settings.getShellConfig();
+	const snapshotPath = shell.includes("bash") ? await getOrCreateSnapshot(shell, shellEnv) : null;
 
-async function executeBashOnce(
-	command: string,
-	options: BashExecutorOptions | undefined,
-	config: {
-		shell: string;
-		args: string[];
-		env: Record<string, string | undefined>;
-		prefix?: string;
-		snapshotPath: string | null;
-	},
-): Promise<BashResult> {
-	const { shell, args, env, prefix, snapshotPath } = config;
-
-	// Merge additional env vars if provided
-	const finalEnv = options?.env ? { ...env, ...options.env } : env;
-	const snapshotPrefix = getSnapshotSourceCommand(snapshotPath);
+	// Apply command prefix if configured
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;
-	const finalCommand = `${snapshotPrefix}${prefixedCommand}`;
+	const finalCommand = prefixedCommand;
 
+	// Create output sink for truncation and artifact handling
 	const sink = new OutputSink({
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
 	});
 
-	using child = ptree.spawn([shell, ...args, finalCommand], {
-		cwd: options?.cwd,
-		env: finalEnv,
-		signal: options?.signal,
-		timeout: options?.timeout,
-	});
+	let pendingChunks = Promise.resolve();
+	const enqueueChunk = (chunk: string) => {
+		pendingChunks = pendingChunks.then(() => sink.push(chunk)).catch(() => {});
+	};
 
-	// Pump streams - errors during abort/timeout are expected
-	// Use preventClose to avoid closing the shared sink when either stream finishes
-	await Promise.allSettled([child.stdout.pipeTo(sink.createInput()), child.stderr.pipeTo(sink.createInput())]).catch(
-		() => {},
-	);
+	if (options?.signal?.aborted) {
+		return {
+			exitCode: undefined,
+			cancelled: true,
+			...(await sink.dump("Command cancelled")),
+		};
+	}
+
+	let abortListener: (() => void) | undefined;
 
-	// Wait for process exit
 	try {
+		const sessionKey = buildSessionKey(shell, prefix, snapshotPath, shellEnv, options?.sessionKey);
+		let shellSession = shellSessions.get(sessionKey);
+		if (!shellSession) {
+			shellSession = new Shell({ sessionEnv: shellEnv, snapshotPath: snapshotPath ?? undefined });
+			shellSessions.set(sessionKey, shellSession);
+		}
+
+		if (options?.signal) {
+			abortListener = () => {
+				shellSession?.abort();
+			};
+			options.signal.addEventListener("abort", abortListener, { once: true });
+		}
+
+		const result = await shellSession.run(
+			{
+				command: finalCommand,
+				cwd: options?.cwd,
+				env: options?.env,
+				timeoutMs: options?.timeout,
+			},
+			(err, chunk) => {
+				if (!err) {
+					enqueueChunk(chunk);
+				}
+			},
+		);
+
+		await pendingChunks;
+
+		// Handle timeout
+		if (result.timedOut) {
+			const annotation = options?.timeout
+				? `Command timed out after ${Math.round(options.timeout / 1000)} seconds`
+				: "Command timed out";
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump(annotation)),
+			};
+		}
+
+		// Handle cancellation
+		if (result.cancelled) {
+			return {
+				exitCode: undefined,
+				cancelled: true,
+				...(await sink.dump("Command cancelled")),
+			};
+		}
+
+		// Normal completion
 		return {
-			exitCode: await child.exited,
+			exitCode: result.exitCode,
 			cancelled: false,
 			...(await sink.dump()),
 		};
-	} catch (err: unknown) {
-		// Exception covers NonZeroExitError, AbortError, TimeoutError
-		if (err instanceof Exception) {
-			if (err.aborted) {
-				const isTimeout = err instanceof ptree.TimeoutError || err.message.toLowerCase().includes("timed out");
-				const annotation = isTimeout
-					? `Command timed out after ${Math.round((options?.timeout ?? 0) / 1000)} seconds`
-					: undefined;
-				return {
-					exitCode: undefined,
-					cancelled: true,
-					...(await sink.dump(annotation)),
-				};
-			}
-
-			// NonZeroExitError
-			return {
-				exitCode: err.exitCode,
-				cancelled: false,
-				...(await sink.dump()),
-			};
+	} finally {
+		await pendingChunks;
+		if (options?.signal && abortListener) {
+			options.signal.removeEventListener("abort", abortListener);
 		}
-
-		throw err;
 	}
 }
+
+function buildSessionKey(
+	shell: string,
+	prefix: string | undefined,
+	snapshotPath: string | null,
+	env: Record<string, string>,
+	agentSessionKey?: string,
+): string {
+	const entries = Object.entries(env);
+	entries.sort(([a], [b]) => a.localeCompare(b));
+	const envSerialized = entries.map(([key, value]) => `${key}=${value}`).join("\n");
+	return [agentSessionKey ?? "", shell, prefix ?? "", snapshotPath ?? "", envSerialized].join("\n");
+}

package/src/ipy/executor.ts

@@ -424,7 +424,8 @@ export async function executePython(code: string, options?: PythonExecutorOption
 	await ensureKernelAvailable(cwd);
 
 	const kernelMode = options?.kernelMode ?? "session";
-	const useSharedGateway = options?.useSharedGateway;
+	const isTestEnv = process.env.BUN_ENV === "test" || process.env.NODE_ENV === "test";
+	const useSharedGateway = isTestEnv ? false : options?.useSharedGateway;
 	const sessionFile = options?.sessionFile;
 	const artifactsDir = options?.artifactsDir;
 

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

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
+import { copyToClipboard } from "@oh-my-pi/pi-natives";
 import { Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@oh-my-pi/pi-tui";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
@@ -18,7 +19,6 @@ import type { InteractiveModeContext } from "../../modes/types";
 import { createCompactionSummaryMessage } from "../../session/messages";
 import { outputMeta } from "../../tools/output-meta";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog";
-import { copyToClipboard } from "../../utils/clipboard";
 
 export class CommandController {
 	constructor(private readonly ctx: InteractiveModeContext) {}

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

@@ -3,13 +3,13 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { readImageFromClipboard } from "@oh-my-pi/pi-natives";
 import { nanoid } from "nanoid";
 import { settings } from "../../config/settings";
 import { theme } from "../../modes/theme/theme";
 import type { InteractiveModeContext } from "../../modes/types";
 import type { AgentSessionEvent } from "../../session/agent-session";
 import { SKILL_PROMPT_MESSAGE_TYPE, type SkillPromptDetails } from "../../session/messages";
-import { readImageFromClipboard } from "../../utils/clipboard";
 import { resizeImage } from "../../utils/image-resize";
 import { generateSessionTitle, setTerminalTitle } from "../../utils/title-generator";
 
@@ -563,17 +563,18 @@ export class InputController {
 		try {
 			const image = await readImageFromClipboard();
 			if (image) {
-				let imageData = image;
+				const base64Data = Buffer.from(image.data).toString("base64");
+				let imageData = { data: base64Data, mimeType: image.mimeType };
 				if (settings.get("images.autoResize")) {
 					try {
 						const resized = await resizeImage({
 							type: "image",
-							data: image.data,
+							data: base64Data,
 							mimeType: image.mimeType,
 						});
 						imageData = { data: resized.data, mimeType: resized.mimeType };
 					} catch {
-						imageData = image;
+						imageData = { data: base64Data, mimeType: image.mimeType };
 					}
 				}
 

package/src/session/agent-session.ts

@@ -3080,6 +3080,7 @@ Be thorough - include exact file paths, function names, error messages, and tech
 			const result = await executeBashCommand(command, {
 				onChunk,
 				signal: this._bashAbortController.signal,
+				sessionKey: this.sessionId,
 			});
 
 			this.recordBashResult(command, result, options);