@oh-my-pi/pi-coding-agent 6.8.1 → 6.8.3

package/src/core/tools/task/worker.ts

@@ -799,10 +799,11 @@ const reportFatal = async (message: string): Promise<void> => {
 	} catch {
 		// Ignore cleanup errors
 	}
+	const error = new Error(message);
 
 	const runState = activeRun;
 	if (runState) {
-		runState.abortController.abort();
+		runState.abortController.abort(error);
 		if (runState.session) {
 			void runState.session.abort();
 		}

package/src/core/tools/todo-write.ts

@@ -1,5 +1,4 @@
 import { randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
 import path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
@@ -13,7 +12,6 @@ import todoWriteDescription from "../../prompts/tools/todo-write.md" with { type
 import type { RenderResultOptions } from "../custom-tools/types";
 import { renderPromptTemplate } from "../prompt-templates";
 import type { ToolSession } from "../sdk";
-import { ensureArtifactsDir, getArtifactsDir } from "./task/artifacts";
 
 const todoWriteSchema = Type.Object({
 	todos: Type.Array(
@@ -135,10 +133,6 @@ async function loadTodoFile(filePath: string): Promise<TodoFile | null> {
 	}
 }
 
-async function saveTodoFile(filePath: string, data: TodoFile): Promise<void> {
-	await Bun.write(filePath, JSON.stringify(data, null, 2));
-}
-
 function formatTodoSummary(todos: TodoItem[]): string {
 	if (todos.length === 0) return "Todo list cleared.";
 	const completed = todos.filter((t) => t.status === "completed").length;
@@ -200,24 +194,14 @@ export class TodoWriteTool implements AgentTool<typeof todoWriteSchema, TodoWrit
 			};
 		}
 
-		const artifactsDir = getArtifactsDir(sessionFile);
-		if (!artifactsDir) {
-			return {
-				content: [{ type: "text", text: formatTodoSummary(todos) }],
-				details: { todos, updatedAt, storage: "memory" },
-			};
-		}
-
-		ensureArtifactsDir(artifactsDir);
-		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
+		const todoPath = path.join(sessionFile.slice(0, -6), TODO_FILE_NAME);
 		const existing = await loadTodoFile(todoPath);
 		const storedTodos = existing?.todos ?? [];
 		const merged = todos.length > 0 ? todos : [];
 		const fileData: TodoFile = { updatedAt, todos: merged };
 
 		try {
-			mkdirSync(artifactsDir, { recursive: true });
-			await saveTodoFile(todoPath, fileData);
+			await Bun.write(todoPath, JSON.stringify(fileData, null, 2));
 		} catch (error) {
 			logger.error("Failed to write todo file", { path: todoPath, error: String(error) });
 			return {

package/src/core/tools/web-scrapers/youtube.ts

@@ -2,7 +2,6 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { cspawn } from "@oh-my-pi/pi-utils";
-import type { FileSink } from "bun";
 import { nanoid } from "nanoid";
 import { ensureTool } from "../../../utils/tools-manager";
 import type { RenderResult, SpecialHandler } from "./types";
@@ -16,59 +15,17 @@ async function exec(
 	args: string[],
 	options?: { timeout?: number; input?: string | Buffer; signal?: AbortSignal },
 ): Promise<{ stdout: string; stderr: string; ok: boolean; exitCode: number | null }> {
-	const controller = new AbortController();
-	const onAbort = () => controller.abort(options?.signal?.reason ?? new Error("Aborted"));
-	if (options?.signal) {
-		if (options.signal.aborted) {
-			onAbort();
-		} else {
-			options.signal.addEventListener("abort", onAbort, { once: true });
-		}
-	}
-	const timeoutId =
-		options?.timeout && options.timeout > 0
-			? setTimeout(() => controller.abort(new Error("Timeout")), options.timeout)
-			: undefined;
 	const proc = cspawn([cmd, ...args], {
-		signal: controller.signal,
+		signal: options?.signal,
+		timeout: options?.timeout,
+		stdin: options?.input ? Buffer.from(options.input) : undefined,
 	});
 
-	if (options?.input && proc.stdin) {
-		const stdin = proc.stdin as FileSink;
-		const payload = typeof options.input === "string" ? new TextEncoder().encode(options.input) : options.input;
-		stdin.write(payload);
-		const flushed = stdin.flush();
-		if (flushed instanceof Promise) {
-			await flushed;
-		}
-		const ended = stdin.end();
-		if (ended instanceof Promise) {
-			await ended;
-		}
-	}
-
 	const [stdout, stderr, exitResult] = await Promise.all([
-		new Response(proc.stdout).text(),
-		new Response(proc.stderr).text(),
-		(async () => {
-			try {
-				await proc.exited;
-				return proc.exitCode ?? 0;
-			} catch (err) {
-				if (err && typeof err === "object" && "exitCode" in err) {
-					const exitValue = (err as { exitCode?: number }).exitCode;
-					if (typeof exitValue === "number") {
-						return exitValue;
-					}
-				}
-				throw err instanceof Error ? err : new Error(String(err));
-			}
-		})(),
+		proc.stdout.text(),
+		proc.stderr.text(),
+		proc.exited.then(() => proc.exitCode ?? 0),
 	]);
-	if (timeoutId) clearTimeout(timeoutId);
-	if (options?.signal) {
-		options.signal.removeEventListener("abort", onAbort);
-	}
 
 	return {
 		stdout,

package/src/lib/worktree/collapse.ts

@@ -1,6 +1,6 @@
 import { nanoid } from "nanoid";
 import { WorktreeError, WorktreeErrorCode } from "./errors";
-import { git, gitWithStdin } from "./git";
+import { git, gitWithInput } from "./git";
 import { find, remove, type Worktree } from "./operations";
 
 export type CollapseStrategy = "simple" | "merge-base" | "rebase";
@@ -121,10 +121,10 @@ async function collapseRebase(src: Worktree, dst: Worktree): Promise<string> {
 }
 
 async function applyDiff(diff: string, targetPath: string): Promise<void> {
-	let result = await gitWithStdin(["apply"], diff, targetPath);
+	let result = await gitWithInput(["apply"], diff, targetPath);
 	if (result.code === 0) return;
 
-	result = await gitWithStdin(["apply", "--3way"], diff, targetPath);
+	result = await gitWithInput(["apply", "--3way"], diff, targetPath);
 	if (result.code === 0) return;
 
 	throw new WorktreeError(

package/src/lib/worktree/git.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import type { Subprocess } from "bun";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { execCommand } from "../../core/exec";
 import { WorktreeError, WorktreeErrorCode } from "./errors";
 
@@ -9,32 +9,6 @@ export interface GitResult {
 	stderr: string;
 }
 
-type WritableLike = {
-	write: (chunk: string | Uint8Array) => unknown;
-	flush?: () => unknown;
-	end?: () => unknown;
-};
-
-const textEncoder = new TextEncoder();
-
-async function writeStdin(handle: unknown, stdin: string): Promise<void> {
-	if (!handle || typeof handle === "number") return;
-	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
-		const writer = (handle as WritableStream<Uint8Array>).getWriter();
-		try {
-			await writer.write(textEncoder.encode(stdin));
-		} finally {
-			await writer.close();
-		}
-		return;
-	}
-
-	const sink = handle as WritableLike;
-	sink.write(stdin);
-	if (sink.flush) sink.flush();
-	if (sink.end) sink.end();
-}
-
 /**
  * Execute a git command.
  * @param args - Command arguments (excluding 'git')
@@ -50,23 +24,15 @@ export async function git(args: string[], cwd?: string): Promise<GitResult> {
  * Execute git command with stdin input.
  * Used for piping diffs to `git apply`.
  */
-export async function gitWithStdin(args: string[], stdin: string, cwd?: string): Promise<GitResult> {
-	const proc: Subprocess = Bun.spawn(["git", ...args], {
+export async function gitWithInput(args: string[], stdin: string, cwd?: string): Promise<GitResult> {
+	const proc = ptree.cspawn(["git", ...args], {
 		cwd: cwd ?? process.cwd(),
-		stdin: "pipe",
-		stdout: "pipe",
-		stderr: "pipe",
+		stdin: Buffer.from(stdin),
 	});
 
-	await writeStdin(proc.stdin, stdin);
-
-	const [stdout, stderr, exitCode] = await Promise.all([
-		(proc.stdout as ReadableStream<Uint8Array>).text(),
-		(proc.stderr as ReadableStream<Uint8Array>).text(),
-		proc.exited,
-	]);
+	const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
 
-	return { code: exitCode ?? 0, stdout, stderr };
+	return { code: proc.exitCode ?? 0, stdout, stderr };
 }
 
 /**

package/src/lib/worktree/index.ts

@@ -1,7 +1,7 @@
 export { type CollapseOptions, type CollapseResult, type CollapseStrategy, collapse } from "./collapse";
 export { WORKTREE_BASE } from "./constants";
 export { WorktreeError, WorktreeErrorCode } from "./errors";
-export { getRepoName, getRepoRoot, git, gitWithStdin } from "./git";
+export { getRepoName, getRepoRoot, git, gitWithInput as gitWithStdin } from "./git";
 export { create, find, list, prune, remove, type Worktree, which } from "./operations";
 export {
 	cleanupSessions,

package/src/modes/interactive/components/todo-display.ts

@@ -1,7 +1,6 @@
 import * as path from "node:path";
 import { Text } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
-import { getArtifactsDir } from "../../../core/tools/task/artifacts";
 import { theme } from "../theme/theme";
 import type { TodoItem } from "../types";
 
@@ -40,13 +39,7 @@ export class TodoDisplayComponent {
 			return;
 		}
 
-		const artifactsDir = getArtifactsDir(this.sessionFile);
-		if (!artifactsDir) {
-			this.todos = [];
-			this.visible = false;
-			return;
-		}
-
+		const artifactsDir = this.sessionFile.slice(0, -6); // strip .jsonl extension
 		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
 		const data = await loadTodoFile(todoPath);
 		this.todos = data?.todos ?? [];

package/src/modes/interactive/components/tree-selector.ts

@@ -707,7 +707,7 @@ class TreeList implements Component {
 				this.searchQuery = this.searchQuery.slice(0, -1);
 				this.applyFilter();
 			}
-		} else if (keyData === "l" && !this.searchQuery) {
+		} else if (matchesKey(keyData, "shift+l") && !this.searchQuery) {
 			const selected = this.filteredNodes[this.selectedIndex];
 			if (selected && this.onLabelEdit) {
 				this.onLabelEdit(selected.node.entry.id, selected.node.label);
@@ -821,7 +821,7 @@ export class TreeSelectorComponent extends Container {
 			new TruncatedText(
 				theme.fg(
 					"muted",
-					"  Up/Down: move. Left/Right: page. l: label. Ctrl+O/Shift+Ctrl+O: filter. Alt+D/T/U/L/A: filter. Type to search",
+					"  Up/Down: move. Left/Right: page. Shift+L: label. Ctrl+O/Shift+Ctrl+O: filter. Alt+D/T/U/L/A: filter. Type to search",
 				),
 				0,
 				0,

package/src/modes/interactive/interactive-mode.ts

@@ -28,7 +28,6 @@ import { getRecentSessions } from "../../core/session-manager";
 import type { SettingsManager } from "../../core/settings-manager";
 import { loadSlashCommands } from "../../core/slash-commands";
 import { setTerminalTitle } from "../../core/title-generator";
-import { getArtifactsDir } from "../../core/tools/task/artifacts";
 import { VoiceSupervisor } from "../../core/voice-supervisor";
 import type { AssistantMessageComponent } from "./components/assistant-message";
 import type { BashExecutionComponent } from "./components/bash-execution";
@@ -384,15 +383,6 @@ export class InteractiveMode implements InteractiveModeContext {
 
 		// Initial top border update
 		this.updateEditorTopBorder();
-
-		if (!startupQuiet) {
-			const templateNames = this.session.promptTemplates.map((template) => template.name).sort();
-			if (templateNames.length > 0) {
-				const preview = templateNames.slice(0, 3).join(", ");
-				const suffix = templateNames.length > 3 ? ` +${templateNames.length - 3} more` : "";
-				this.showStatus(`Loaded prompt templates: ${preview}${suffix}`);
-			}
-		}
 	}
 
 	async getUserInput(): Promise<{ text: string; images?: ImageContent[] }> {
@@ -481,11 +471,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.renderTodoList();
 			return;
 		}
-		const artifactsDir = getArtifactsDir(sessionFile);
-		if (!artifactsDir) {
-			this.renderTodoList();
-			return;
-		}
+		const artifactsDir = sessionFile.slice(0, -6);
 		const todoPath = path.join(artifactsDir, TODO_FILE_NAME);
 		const file = Bun.file(todoPath);
 		if (!(await file.exists())) {

package/src/utils/clipboard.ts

@@ -32,35 +32,40 @@ function selectPreferredImageMimeType(mimeTypes: string[]): string | null {
 }
 
 export async function copyToClipboard(text: string): Promise<void> {
-	const timeout = Bun.sleep(3000).then(() => Promise.reject(new Error("Clipboard operation timed out")));
+	const p = platform();
+	const timeout = 5000;
 
-	let promise: Promise<void>;
 	try {
-		switch (platform()) {
-			case "darwin":
-				promise = $`pbcopy ${text}`.quiet().then(() => void 0);
-				break;
-			case "win32":
-				promise = $`clip ${text}`.quiet().then(() => void 0);
-				break;
-			case "linux":
-				if (isWaylandSession()) {
-					$`wl-copy ${text}`.quiet(); // fire and forget
+		if (p === "darwin") {
+			await Bun.spawn(["pbcopy"], { stdin: Buffer.from(text), timeout }).exited;
+		} else if (p === "win32") {
+			await Bun.spawn(["clip"], { stdin: Buffer.from(text), timeout }).exited;
+		} else {
+			const wayland = isWaylandSession();
+			if (wayland) {
+				const wlCopyPath = Bun.which("wl-copy");
+				if (wlCopyPath) {
+					// Fire-and-forget: wl-copy may not exit promptly, so we unref to avoid blocking
+					void Bun.spawn([wlCopyPath], { stdin: Buffer.from(text), timeout }).unref();
 					return;
-				} else {
-					promise = $`xclip -selection clipboard -t text/plain -i ${text}`.quiet().then(() => void 0);
 				}
-				break;
-			default:
-				throw new Error(`Unsupported platform: ${platform()}`);
+			}
+
+			// Linux - try xclip first, fall back to xsel
+			try {
+				await Bun.spawn(["xclip", "-selection", "clipboard"], { stdin: Buffer.from(text), timeout }).exited;
+			} catch {
+				await Bun.spawn(["xsel", "--clipboard", "--input"], { stdin: Buffer.from(text), timeout }).exited;
+			}
 		}
 	} catch (error) {
-		if (error instanceof Error) {
-			throw new Error(`Failed to copy to clipboard: ${error.message}`);
+		const msg = error instanceof Error ? error.message : String(error);
+		if (p === "linux") {
+			const tools = isWaylandSession() ? "wl-copy, xclip, or xsel" : "xclip or xsel";
+			throw new Error(`Failed to copy to clipboard. Install ${tools}: ${msg}`);
 		}
-		throw new Error(`Failed to copy to clipboard: ${String(error)}`);
+		throw new Error(`Failed to copy to clipboard: ${msg}`);
 	}
-	await Promise.race([promise, timeout]);
 }
 
 export interface ClipboardImage {

package/src/core/tools/task/artifacts.ts

@@ -1,112 +0,0 @@
-/**
- * Session artifacts for subagent outputs.
- *
- * When a session exists, writes agent outputs to a sibling directory.
- * Otherwise uses temp files that are cleaned up after execution.
- */
-
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { nanoid } from "nanoid";
-
-/**
- * Derive artifacts directory from session file path.
- *
- * /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid.jsonl
- *   → /path/to/sessions/project/2026-01-01T14-28-11-636Z_uuid/
- */
-export function getArtifactsDir(sessionFile: string | null): string | null {
-	if (!sessionFile) return null;
-	// Strip .jsonl extension to get directory path
-	if (sessionFile.endsWith(".jsonl")) {
-		return sessionFile.slice(0, -6);
-	}
-	return sessionFile;
-}
-
-/**
- * Ensure artifacts directory exists.
- */
-export function ensureArtifactsDir(dir: string): void {
-	if (!fs.existsSync(dir)) {
-		fs.mkdirSync(dir, { recursive: true });
-	}
-}
-
-/**
- * Generate artifact file paths for an agent run.
- */
-export function getArtifactPaths(
-	dir: string,
-	taskId: string,
-): { inputPath: string; outputPath: string; jsonlPath: string } {
-	return {
-		inputPath: path.join(dir, `${taskId}.in.md`),
-		outputPath: path.join(dir, `${taskId}.out.md`),
-		jsonlPath: path.join(dir, `${taskId}.jsonl`),
-	};
-}
-
-/**
- * Write artifacts for an agent run.
- */
-export async function writeArtifacts(
-	dir: string,
-	taskId: string,
-	input: string,
-	output: string,
-	jsonlEvents?: string[],
-): Promise<{ inputPath: string; outputPath: string; jsonlPath?: string }> {
-	ensureArtifactsDir(dir);
-
-	const paths = getArtifactPaths(dir, taskId);
-
-	// Write input
-	await Bun.write(paths.inputPath, input);
-
-	// Write output
-	await Bun.write(paths.outputPath, output);
-
-	// Write JSONL if events provided
-	if (jsonlEvents && jsonlEvents.length > 0) {
-		await Bun.write(paths.jsonlPath, jsonlEvents.join("\n"));
-		return paths;
-	}
-
-	return { inputPath: paths.inputPath, outputPath: paths.outputPath };
-}
-
-/**
- * Create a temporary artifacts directory.
- */
-export function createTempArtifactsDir(runId?: string): string {
-	const id = runId || nanoid();
-	const dir = path.join(os.tmpdir(), `omp-task-${id}`);
-	ensureArtifactsDir(dir);
-	return dir;
-}
-
-/**
- * Clean up temporary artifacts.
- */
-export async function cleanupTempArtifacts(paths: string[]): Promise<void> {
-	for (const p of paths) {
-		try {
-			await fs.promises.unlink(p);
-		} catch {
-			// Ignore cleanup errors
-		}
-	}
-}
-
-/**
- * Clean up a temporary directory and its contents.
- */
-export async function cleanupTempDir(dir: string): Promise<void> {
-	try {
-		await fs.promises.rm(dir, { recursive: true, force: true });
-	} catch {
-		// Ignore cleanup errors
-	}
-}