@oh-my-pi/pi-coding-agent 12.12.3 → 12.14.0

package/src/ssh/config-writer.ts

@@ -0,0 +1,183 @@
+/**
+ * SSH Configuration File Writer
+ *
+ * Utilities for reading/writing ssh.json files at user or project level.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+
+export interface SSHHostConfig {
+	host: string;
+	username?: string;
+	port?: number;
+	keyPath?: string;
+	description?: string;
+	compat?: boolean;
+}
+
+export interface SSHConfigFile {
+	hosts?: Record<string, SSHHostConfig>;
+}
+
+/**
+ * Read an SSH config file.
+ * Returns empty config if file doesn't exist.
+ */
+export async function readSSHConfigFile(filePath: string): Promise<SSHConfigFile> {
+	try {
+		const content = await fs.promises.readFile(filePath, "utf-8");
+		const parsed = JSON.parse(content) as SSHConfigFile;
+		return parsed;
+	} catch (error) {
+		if (isEnoent(error)) {
+			// File doesn't exist, return empty config
+			return { hosts: {} };
+		}
+		if (error instanceof SyntaxError) {
+			throw new Error(`Failed to parse SSH config file ${filePath}: ${error.message}`);
+		}
+		throw error;
+	}
+}
+
+/**
+ * Write an SSH config file atomically.
+ * Creates parent directories if they don't exist.
+ */
+export async function writeSSHConfigFile(filePath: string, config: SSHConfigFile): Promise<void> {
+	// Ensure parent directory exists
+	const dir = path.dirname(filePath);
+	await fs.promises.mkdir(dir, { recursive: true, mode: 0o700 });
+
+	// Write to temp file first (atomic write)
+	const tmpPath = `${filePath}.tmp`;
+	const content = JSON.stringify(config, null, 2);
+	await fs.promises.writeFile(tmpPath, content, { encoding: "utf-8", mode: 0o600 });
+
+	// Rename to final path (atomic on most systems)
+	await fs.promises.rename(tmpPath, filePath);
+}
+
+/**
+ * Validate host name.
+ * @returns Error message if invalid, undefined if valid
+ */
+export function validateHostName(name: string): string | undefined {
+	if (!name) {
+		return "Host name cannot be empty";
+	}
+	if (name.length > 100) {
+		return "Host name is too long (max 100 characters)";
+	}
+	// Check for invalid characters (only allow alphanumeric, dash, underscore, dot)
+	if (!/^[a-zA-Z0-9_.-]+$/.test(name)) {
+		return "Host name can only contain letters, numbers, dash, underscore, and dot";
+	}
+	return undefined;
+}
+
+/**
+ * Add an SSH host to a config file.
+ *
+ * @throws Error if host name already exists or validation fails
+ */
+export async function addSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void> {
+	// Validate host name
+	const nameError = validateHostName(name);
+	if (nameError) {
+		throw new Error(nameError);
+	}
+
+	// Validate host field
+	if (!hostConfig.host) {
+		throw new Error("Host address cannot be empty");
+	}
+
+	// Read existing config
+	const existing = await readSSHConfigFile(filePath);
+
+	// Check for duplicate name
+	if (existing.hosts?.[name]) {
+		throw new Error(`Host "${name}" already exists in ${filePath}`);
+	}
+
+	// Add host
+	const updated: SSHConfigFile = {
+		...existing,
+		hosts: {
+			...existing.hosts,
+			[name]: hostConfig,
+		},
+	};
+
+	// Write back
+	await writeSSHConfigFile(filePath, updated);
+}
+
+/**
+ * Update an existing SSH host in a config file.
+ * If the host doesn't exist, this will add it.
+ *
+ * @throws Error if validation fails
+ */
+export async function updateSSHHost(filePath: string, name: string, hostConfig: SSHHostConfig): Promise<void> {
+	// Validate host name
+	const nameError = validateHostName(name);
+	if (nameError) {
+		throw new Error(nameError);
+	}
+
+	// Validate host field
+	if (!hostConfig.host) {
+		throw new Error("Host address cannot be empty");
+	}
+
+	// Read existing config
+	const existing = await readSSHConfigFile(filePath);
+
+	// Update host
+	const updated: SSHConfigFile = {
+		...existing,
+		hosts: {
+			...existing.hosts,
+			[name]: hostConfig,
+		},
+	};
+
+	// Write back
+	await writeSSHConfigFile(filePath, updated);
+}
+
+/**
+ * Remove an SSH host from a config file.
+ *
+ * @throws Error if host doesn't exist
+ */
+export async function removeSSHHost(filePath: string, name: string): Promise<void> {
+	// Read existing config
+	const existing = await readSSHConfigFile(filePath);
+
+	// Check if host exists
+	if (!existing.hosts?.[name]) {
+		throw new Error(`Host "${name}" not found in ${filePath}`);
+	}
+
+	// Remove host
+	const { [name]: _removed, ...remaining } = existing.hosts;
+	const updated: SSHConfigFile = {
+		...existing,
+		hosts: remaining,
+	};
+
+	// Write back
+	await writeSSHConfigFile(filePath, updated);
+}
+
+/**
+ * List all host names in a config file.
+ */
+export async function listSSHHosts(filePath: string): Promise<string[]> {
+	const config = await readSSHConfigFile(filePath);
+	return Object.keys(config.hosts ?? {});
+}

package/src/tools/bash-interactive.ts

@@ -95,6 +95,10 @@ class BashInteractiveOverlayComponent implements Component {
 	#session: PtySession | null = null;
 	#lastCols = 0;
 	#lastRows = 0;
+	#writeQueue: string[] = [];
+	#writeOffset = 0;
+	#flushResolvers: Array<() => void> = [];
+	#writing = false;
 
 	constructor(
 		private readonly command: string,
@@ -117,7 +121,47 @@ class BashInteractiveOverlayComponent implements Component {
 	}
 
 	appendOutput(chunk: string): void {
-		this.#terminal.write(chunk);
+		this.#writeQueue.push(chunk);
+		this.#drainQueue();
+	}
+
+	#drainQueue(): void {
+		if (this.#writing) return;
+		if (this.#writeOffset >= this.#writeQueue.length) {
+			this.#resolveFlushWaiters();
+			return;
+		}
+		this.#writing = true;
+		const data = this.#writeQueue[this.#writeOffset]!;
+		this.#terminal.write(data, () => {
+			this.#writing = false;
+			this.#writeOffset += 1;
+			if (this.#writeOffset >= this.#writeQueue.length) {
+				this.#writeQueue = [];
+				this.#writeOffset = 0;
+				this.#resolveFlushWaiters();
+			}
+			this.#drainQueue();
+		});
+	}
+
+	#resolveFlushWaiters(): void {
+		if (this.#writing || this.#writeOffset < this.#writeQueue.length) return;
+		if (this.#flushResolvers.length === 0) return;
+		const resolvers = this.#flushResolvers;
+		this.#flushResolvers = [];
+		for (const resolve of resolvers) {
+			resolve();
+		}
+	}
+
+	flushOutput(): Promise<void> {
+		if (!this.#writing && this.#writeOffset >= this.#writeQueue.length) {
+			return Promise.resolve();
+		}
+		const { promise, resolve } = Promise.withResolvers<void>();
+		this.#flushResolvers.push(resolve);
+		return promise;
 	}
 
 	setSession(session: PtySession): void {
@@ -258,6 +302,7 @@ export async function runInteractiveBashPty(
 				component.setComplete({ exitCode: run.exitCode, cancelled: run.cancelled, timedOut: run.timedOut });
 				tui.requestRender();
 				void (async () => {
+					await component.flushOutput();
 					await pendingChunks;
 					const summary = await sink.dump();
 					done({
@@ -349,12 +394,7 @@ export async function runInteractiveBashPty(
 					},
 					(err, chunk) => {
 						if (err || !chunk) return;
-						try {
-							component.appendOutput(chunk);
-						} catch {
-							const normalizedChunk = normalizeCaptureChunk(chunk);
-							component.appendOutput(normalizedChunk);
-						}
+						component.appendOutput(chunk);
 						const normalizedChunk = normalizeCaptureChunk(chunk);
 						pendingChunks = pendingChunks.then(() => sink.push(normalizedChunk)).catch(() => {});
 						tui.requestRender();

package/src/tools/fetch.ts

@@ -966,11 +966,12 @@ function countNonEmptyLines(text: string): number {
 
 /** Render fetch call (URL preview) */
 export function renderFetchCall(
-	args: { url: string; timeout?: number; raw?: boolean },
+	args: { url?: string; timeout?: number; raw?: boolean },
 	uiTheme: Theme = theme,
 ): Component {
-	const domain = getDomain(args.url);
-	const path = truncate(args.url.replace(/^https?:\/\/[^/]+/, ""), 50, "…");
+	const url = args.url ?? "";
+	const domain = getDomain(url);
+	const path = truncate(url.replace(/^https?:\/\/[^/]+/, ""), 50, "\u2026");
 	const description = `${domain}${path ? ` ${path}` : ""}`.trim();
 	const meta: string[] = [];
 	if (args.raw) meta.push("raw");

package/src/tools/grep.ts

@@ -104,7 +104,17 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 			const effectiveMultiline = multiline ?? patternHasNewline;
 
 			const useHashLines = resolveFileDisplayMode(this.session).hashLines;
-			const searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
+			let searchPath: string;
+			const internalRouter = this.session.internalRouter;
+			if (searchDir && internalRouter?.canHandle(searchDir)) {
+				const resource = await internalRouter.resolve(searchDir);
+				if (!resource.sourcePath) {
+					throw new ToolError(`Cannot grep internal URL without a backing file: ${searchDir}`);
+				}
+				searchPath = resource.sourcePath;
+			} else {
+				searchPath = resolveToCwd(searchDir || ".", this.session.cwd);
+			}
 			const scopePath = (() => {
 				const relative = path.relative(this.session.cwd, searchPath).replace(/\\/g, "/");
 				return relative.length === 0 ? "." : relative;
@@ -209,11 +219,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 
 				const formatLine = (lineNumber: number, line: string, isMatch: boolean): string => {
 					if (useHashLines) {
-						const ref = `${lineNumber}:${computeLineHash(lineNumber, line)}`;
-						return isMatch ? `>>${ref}|${line}` : `  ${ref}|${line}`;
+						const ref = `${lineNumber}#${computeLineHash(lineNumber, line)}`;
+						return isMatch ? `>>${ref}:${line}` : `  ${ref}:${line}`;
 					}
 					const padded = lineNumber.toString().padStart(lineWidth, " ");
-					return isMatch ? `>>${padded}|${line}` : `  ${padded}|${line}`;
+					return isMatch ? `>>${padded}:${line}` : `  ${padded}:${line}`;
 				};
 
 				// Add context before

package/src/tools/read.ts

@@ -772,7 +772,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 			const prependHashLines = (text: string, startNum: number): string => {
 				const textLines = text.split("\n");
 				return textLines
-					.map((line, i) => `${startNum + i}:${computeLineHash(startNum + i, line)}|${line}`)
+					.map((line, i) => `${startNum + i}#${computeLineHash(startNum + i, line)}:${line}`)
 					.join("\n");
 			};
 			const formatText = (text: string, startNum: number): string => {
@@ -929,7 +929,7 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 		};
 		const prependHashLines = (text: string, startNum: number): string => {
 			const textLines = text.split("\n");
-			return textLines.map((line, i) => `${startNum + i}:${computeLineHash(startNum + i, line)}|${line}`).join("\n");
+			return textLines.map((line, i) => `${startNum + i}#${computeLineHash(startNum + i, line)}:${line}`).join("\n");
 		};
 		const formatText = (text: string, startNum: number): string => {
 			if (shouldAddHashLines) return prependHashLines(text, startNum);

package/src/tools/ssh.ts

@@ -23,7 +23,7 @@ import { toolResult } from "./tool-result";
 import { DEFAULT_MAX_BYTES } from "./truncate";
 
 const sshSchema = Type.Object({
-	host: Type.String({ description: "Host name from ssh.json or .ssh.json" }),
+	host: Type.String({ description: "Host name from managed SSH config or discovered ssh.json files" }),
 	command: Type.String({ description: "Command to execute on the remote host" }),
 	cwd: Type.Optional(Type.String({ description: "Remote working directory (optional)" })),
 	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 60)" })),

package/src/web/search/render.ts

@@ -282,11 +282,11 @@ export function renderSearchResult(
 
 /** Render web search call (query preview) */
 export function renderSearchCall(
-	args: { query: string; provider?: string; [key: string]: unknown },
+	args: { query?: string; provider?: string; [key: string]: unknown },
 	theme: Theme,
 ): Component {
 	const provider = args.provider ?? "auto";
-	const query = truncateToWidth(args.query, 80);
+	const query = truncateToWidth(args.query ?? "", 80);
 	const text = renderStatusLine({ icon: "pending", title: "Web Search", description: query, meta: [provider] }, theme);
 	return new Text(text, 0, 0);
 }