@oh-my-pi/pi-coding-agent 3.25.0 → 3.31.0

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

@@ -0,0 +1,371 @@
+import { unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import type { FileSink } from "bun";
+import { nanoid } from "nanoid";
+import { ensureTool } from "../../../utils/tools-manager";
+import type { RenderResult, SpecialHandler } from "./types";
+import { finalizeOutput } from "./types";
+
+/**
+ * Execute a command and return stdout
+ */
+async function exec(
+	cmd: string,
+	args: string[],
+	options?: { timeout?: number; input?: string | Buffer; signal?: AbortSignal },
+): Promise<{ stdout: string; stderr: string; ok: boolean; exitCode: number | null }> {
+	const proc = Bun.spawn([cmd, ...args], {
+		stdin: options?.input ? "pipe" : "ignore",
+		stdout: "pipe",
+		stderr: "pipe",
+		timeout: options?.timeout,
+		signal: options?.signal,
+	});
+
+	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] = await Promise.all([
+		(proc.stdout as ReadableStream<Uint8Array>).text(),
+		(proc.stderr as ReadableStream<Uint8Array>).text(),
+	]);
+	const exitCode = await proc.exited;
+
+	return {
+		stdout,
+		stderr,
+		ok: exitCode === 0,
+		exitCode,
+	};
+}
+
+interface YouTubeUrl {
+	videoId: string;
+	playlistId?: string;
+}
+
+/**
+ * Parse YouTube URL into components
+ */
+function parseYouTubeUrl(url: string): YouTubeUrl | null {
+	try {
+		const parsed = new URL(url);
+		const hostname = parsed.hostname.replace(/^www\./, "");
+
+		// youtube.com/watch?v=VIDEO_ID
+		if ((hostname === "youtube.com" || hostname === "m.youtube.com") && parsed.pathname === "/watch") {
+			const videoId = parsed.searchParams.get("v");
+			const playlistId = parsed.searchParams.get("list") || undefined;
+			if (videoId) return { videoId, playlistId };
+		}
+
+		// youtube.com/v/VIDEO_ID or youtube.com/embed/VIDEO_ID
+		if (hostname === "youtube.com" || hostname === "m.youtube.com") {
+			const match = parsed.pathname.match(/^\/(v|embed)\/([a-zA-Z0-9_-]{11})/);
+			if (match) return { videoId: match[2] };
+		}
+
+		// youtu.be/VIDEO_ID
+		if (hostname === "youtu.be") {
+			const videoId = parsed.pathname.slice(1).split("/")[0];
+			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+				return { videoId };
+			}
+		}
+
+		// youtube.com/shorts/VIDEO_ID
+		if (hostname === "youtube.com" && parsed.pathname.startsWith("/shorts/")) {
+			const videoId = parsed.pathname.replace("/shorts/", "").split("/")[0];
+			if (videoId && /^[a-zA-Z0-9_-]{11}$/.test(videoId)) {
+				return { videoId };
+			}
+		}
+	} catch {}
+
+	return null;
+}
+
+/**
+ * Clean VTT subtitle content to plain text
+ */
+function cleanVttToText(vtt: string): string {
+	const lines = vtt.split("\n");
+	const textLines: string[] = [];
+	let lastLine = "";
+
+	for (const line of lines) {
+		// Skip WEBVTT header, timestamps, and metadata
+		if (
+			line.startsWith("WEBVTT") ||
+			line.startsWith("Kind:") ||
+			line.startsWith("Language:") ||
+			line.match(/^\d{2}:\d{2}/) || // Timestamp lines
+			line.match(/^[a-f0-9-]{36}$/) || // UUID cue identifiers
+			line.match(/^\d+$/) || // Numeric cue identifiers
+			line.includes("-->") ||
+			line.trim() === ""
+		) {
+			continue;
+		}
+
+		// Remove inline timestamp tags like <00:00:01.520>
+		let cleaned = line.replace(/<\d{2}:\d{2}:\d{2}\.\d{3}>/g, "");
+		// Remove other VTT tags like <c> </c>
+		cleaned = cleaned.replace(/<\/?[^>]+>/g, "");
+		cleaned = cleaned.trim();
+
+		// Skip duplicates (auto-generated captions often repeat)
+		if (cleaned && cleaned !== lastLine) {
+			textLines.push(cleaned);
+			lastLine = cleaned;
+		}
+	}
+
+	return textLines.join(" ").replace(/\s+/g, " ").trim();
+}
+
+/**
+ * Format duration from seconds to human readable
+ */
+function formatDuration(seconds: number): string {
+	const h = Math.floor(seconds / 3600);
+	const m = Math.floor((seconds % 3600) / 60);
+	const s = Math.floor(seconds % 60);
+	if (h > 0) return `${h}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}`;
+	return `${m}:${s.toString().padStart(2, "0")}`;
+}
+
+/**
+ * Handle YouTube URLs - fetch metadata and transcript
+ */
+export const handleYouTube: SpecialHandler = async (
+	url: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<RenderResult | null> => {
+	signal?.throwIfAborted();
+	const yt = parseYouTubeUrl(url);
+	if (!yt) return null;
+
+	// Ensure yt-dlp is available (auto-download if missing)
+	const ytdlp = await ensureTool("yt-dlp", true);
+	signal?.throwIfAborted();
+	if (!ytdlp) {
+		return {
+			url,
+			finalUrl: url,
+			contentType: "text/plain",
+			method: "youtube-no-ytdlp",
+			content: "YouTube video detected but yt-dlp could not be installed.",
+			fetchedAt: new Date().toISOString(),
+			truncated: false,
+			notes: ["yt-dlp installation failed"],
+		};
+	}
+
+	const fetchedAt = new Date().toISOString();
+	const notes: string[] = [];
+	const videoUrl = `https://www.youtube.com/watch?v=${yt.videoId}`;
+
+	// Fetch video metadata
+	signal?.throwIfAborted();
+	const metaResult = await exec(
+		ytdlp,
+		["--dump-json", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		{
+			timeout: timeout * 1000,
+			signal,
+		},
+	);
+	signal?.throwIfAborted();
+
+	let title = "YouTube Video";
+	let channel = "";
+	let description = "";
+	let duration = 0;
+	let uploadDate = "";
+	let viewCount = 0;
+
+	if (metaResult.ok && metaResult.stdout.trim()) {
+		try {
+			const meta = JSON.parse(metaResult.stdout) as {
+				title?: string;
+				channel?: string;
+				uploader?: string;
+				description?: string;
+				duration?: number;
+				upload_date?: string;
+				view_count?: number;
+			};
+			title = meta.title || title;
+			channel = meta.channel || meta.uploader || "";
+			description = meta.description || "";
+			duration = meta.duration || 0;
+			uploadDate = meta.upload_date || "";
+			viewCount = meta.view_count || 0;
+		} catch {}
+	}
+
+	// Format upload date
+	let formattedDate = "";
+	if (uploadDate && uploadDate.length === 8) {
+		formattedDate = `${uploadDate.slice(0, 4)}-${uploadDate.slice(4, 6)}-${uploadDate.slice(6, 8)}`;
+	}
+
+	// Try to fetch subtitles
+	let transcript = "";
+	let transcriptSource = "";
+
+	// First, list available subtitles
+	signal?.throwIfAborted();
+	const listResult = await exec(
+		ytdlp,
+		["--list-subs", "--no-warnings", "--no-playlist", "--skip-download", videoUrl],
+		{
+			timeout: timeout * 1000,
+			signal,
+		},
+	);
+	signal?.throwIfAborted();
+
+	const hasManualSubs = listResult.stdout.includes("[info] Available subtitles");
+	const hasAutoSubs = listResult.stdout.includes("[info] Available automatic captions");
+
+	// Create temp directory for subtitle download
+	const tmpDir = tmpdir();
+	const tmpBase = path.join(tmpDir, `yt-${yt.videoId}-${nanoid()}`);
+
+	try {
+		// Try manual subtitles first (English preferred)
+		if (hasManualSubs) {
+			signal?.throwIfAborted();
+			const subResult = await exec(
+				ytdlp,
+				[
+					"--write-sub",
+					"--sub-lang",
+					"en,en-US,en-GB",
+					"--sub-format",
+					"vtt",
+					"--skip-download",
+					"--no-warnings",
+					"--no-playlist",
+					"-o",
+					tmpBase,
+					videoUrl,
+				],
+				{ timeout: timeout * 1000, signal },
+			);
+
+			if (subResult.ok) {
+				// Find the downloaded subtitle file using glob
+				signal?.throwIfAborted();
+				const subFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*.vtt`).scan({ absolute: true }));
+				if (subFiles.length > 0) {
+					signal?.throwIfAborted();
+					const vttContent = await Bun.file(subFiles[0]).text();
+					transcript = cleanVttToText(vttContent);
+					transcriptSource = "manual";
+					notes.push("Using manual subtitles");
+				}
+			}
+		}
+
+		// Fall back to auto-generated captions
+		if (!transcript && hasAutoSubs) {
+			signal?.throwIfAborted();
+			const autoResult = await exec(
+				ytdlp,
+				[
+					"--write-auto-sub",
+					"--sub-lang",
+					"en,en-US,en-GB",
+					"--sub-format",
+					"vtt",
+					"--skip-download",
+					"--no-warnings",
+					"--no-playlist",
+					"-o",
+					tmpBase,
+					videoUrl,
+				],
+				{ timeout: timeout * 1000, signal },
+			);
+
+			if (autoResult.ok) {
+				signal?.throwIfAborted();
+				const subFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*.vtt`).scan({ absolute: true }));
+				if (subFiles.length > 0) {
+					signal?.throwIfAborted();
+					const vttContent = await Bun.file(subFiles[0]).text();
+					transcript = cleanVttToText(vttContent);
+					transcriptSource = "auto-generated";
+					notes.push("Using auto-generated captions");
+				}
+			}
+		}
+	} finally {
+		// Cleanup temp files using sync unlink to avoid leaving handles open
+		try {
+			const tmpFiles = await Array.fromAsync(new Bun.Glob(`${tmpBase}*`).scan({ absolute: true }));
+			for (const f of tmpFiles) {
+				try {
+					unlinkSync(f);
+				} catch {}
+			}
+		} catch {}
+	}
+
+	// Build markdown output
+	let md = `# ${title}\n\n`;
+	if (channel) md += `**Channel:** ${channel}\n`;
+	if (formattedDate) md += `**Uploaded:** ${formattedDate}\n`;
+	if (duration > 0) md += `**Duration:** ${formatDuration(duration)}\n`;
+	if (viewCount > 0) {
+		const formatted =
+			viewCount >= 1_000_000
+				? `${(viewCount / 1_000_000).toFixed(1)}M`
+				: viewCount >= 1_000
+					? `${(viewCount / 1_000).toFixed(1)}K`
+					: String(viewCount);
+		md += `**Views:** ${formatted}\n`;
+	}
+	md += `**Video ID:** ${yt.videoId}\n\n`;
+
+	if (description) {
+		// Truncate long descriptions
+		const descPreview = description.length > 1000 ? `${description.slice(0, 1000)}...` : description;
+		md += `---\n\n## Description\n\n${descPreview}\n\n`;
+	}
+
+	if (transcript) {
+		md += `---\n\n## Transcript (${transcriptSource})\n\n${transcript}\n`;
+	} else {
+		notes.push("No subtitles/captions available");
+		md += `---\n\n*No transcript available for this video.*\n`;
+	}
+
+	const output = finalizeOutput(md);
+	return {
+		url,
+		finalUrl: videoUrl,
+		contentType: "text/markdown",
+		method: "youtube",
+		content: output.content,
+		fetchedAt,
+		truncated: output.truncated,
+		notes,
+	};
+};

package/src/core/tools/write.ts

@@ -6,6 +6,7 @@ import { getLanguageFromPath, highlightCode, type Theme } from "../../modes/inte
 import writeDescription from "../../prompts/tools/write.md" with { type: "text" };
 import type { RenderResultOptions } from "../custom-tools/types";
 import type { ToolSession } from "../sdk";
+import { untilAborted } from "../utils";
 import { createLspWritethrough, type FileDiagnosticsResult } from "./lsp/index";
 import { resolveToCwd } from "./path-utils";
 import { formatDiagnostics, replaceTabs, shortenPath } from "./render-utils";
@@ -34,27 +35,29 @@ export function createWriteTool(session: ToolSession): AgentTool<typeof writeSch
 			{ path, content }: { path: string; content: string },
 			signal?: AbortSignal,
 		) => {
-			const absolutePath = resolveToCwd(path, session.cwd);
-
-			const diagnostics = await writethrough(absolutePath, content, signal);
-
-			let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
-			if (!diagnostics) {
+			return untilAborted(signal, async () => {
+				const absolutePath = resolveToCwd(path, session.cwd);
+
+				const diagnostics = await writethrough(absolutePath, content, signal);
+
+				let resultText = `Successfully wrote ${content.length} bytes to ${path}`;
+				if (!diagnostics) {
+					return {
+						content: [{ type: "text", text: resultText }],
+						details: {},
+					};
+				}
+
+				const messages = diagnostics?.messages;
+				if (messages && messages.length > 0) {
+					resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
+					resultText += messages.map((d) => `  ${d}`).join("\n");
+				}
 				return {
 					content: [{ type: "text", text: resultText }],
-					details: {},
+					details: { diagnostics },
 				};
-			}
-
-			const messages = diagnostics?.messages;
-			if (messages && messages.length > 0) {
-				resultText += `\n\nLSP Diagnostics (${diagnostics.summary}):\n`;
-				resultText += messages.map((d) => `  ${d}`).join("\n");
-			}
-			return {
-				content: [{ type: "text", text: resultText }],
-				details: { diagnostics },
-			};
+			});
 		},
 	};
 }

package/src/core/voice.ts

@@ -2,6 +2,7 @@ import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { completeSimple, type Model } from "@mariozechner/pi-ai";
+import { nanoid } from "nanoid";
 import voiceSummaryPrompt from "../prompts/voice-summary.md" with { type: "text" };
 import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";
@@ -99,7 +100,7 @@ function buildRecordingCommand(filePath: string, sampleRate: number, channels: n
 export async function startVoiceRecording(_settings: VoiceSettings): Promise<VoiceRecordingHandle> {
 	const sampleRate = DEFAULT_SAMPLE_RATE;
 	const channels = DEFAULT_CHANNELS;
-	const filePath = join(tmpdir(), `omp-voice-${Date.now()}.wav`);
+	const filePath = join(tmpdir(), `omp-voice-${nanoid()}.wav`);
 	const command = buildRecordingCommand(filePath, sampleRate, channels);
 	if (!command) {
 		throw new Error("No audio recorder found (install sox, arecord, or ffmpeg).");
@@ -233,7 +234,7 @@ function getPlayerCommand(filePath: string, format: VoiceSynthesisResult["format
 }
 
 export async function playAudio(audio: Uint8Array, format: VoiceSynthesisResult["format"]): Promise<void> {
-	const filePath = join(tmpdir(), `omp-voice-tts-${Date.now()}.${format}`);
+	const filePath = join(tmpdir(), `omp-tts-${nanoid()}.${format}`);
 	await Bun.write(filePath, audio);
 
 	const command = getPlayerCommand(filePath, format);

package/src/lib/worktree/collapse.ts

@@ -1,3 +1,4 @@
+import { nanoid } from "nanoid";
 import { WorktreeError, WorktreeErrorCode } from "./errors";
 import { git, gitWithStdin } from "./git";
 import { find, remove, type Worktree } from "./operations";
@@ -89,7 +90,7 @@ async function collapseRebase(src: Worktree, dst: Worktree): Promise<string> {
 		throw new WorktreeError("Failed to resolve HEAD", WorktreeErrorCode.COLLAPSE_FAILED);
 	}
 	const originalHead = headResult.stdout.trim();
-	const tempBranch = `wt-collapse-${Date.now()}`;
+	const tempBranch = `wt-collapse-${nanoid()}`;
 
 	await requireGitSuccess(await git(["checkout", "-b", tempBranch], src.path), "Failed to create temp branch");
 

package/src/lib/worktree/git.ts

@@ -17,22 +17,6 @@ type WritableLike = {
 
 const textEncoder = new TextEncoder();
 
-async function readStream(stream: ReadableStream<Uint8Array> | undefined): Promise<string> {
-	if (!stream) return "";
-	const reader = stream.getReader();
-	const chunks: Uint8Array[] = [];
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	return Buffer.concat(chunks).toString();
-}
-
 async function writeStdin(handle: unknown, stdin: string): Promise<void> {
 	if (!handle || typeof handle === "number") return;
 	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
@@ -77,8 +61,8 @@ export async function gitWithStdin(args: string[], stdin: string, cwd?: string):
 	await writeStdin(proc.stdin, stdin);
 
 	const [stdout, stderr, exitCode] = await Promise.all([
-		readStream(proc.stdout as ReadableStream<Uint8Array>),
-		readStream(proc.stderr as ReadableStream<Uint8Array>),
+		(proc.stdout as ReadableStream<Uint8Array>).text(),
+		(proc.stderr as ReadableStream<Uint8Array>).text(),
 		proc.exited,
 	]);
 

package/src/main.ts

@@ -7,6 +7,8 @@
 
 import { type ImageContent, supportsXhigh } from "@mariozechner/pi-ai";
 import chalk from "chalk";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 import { type Args, parseArgs, printHelp } from "./cli/args";
 import { processFileArguments } from "./cli/file-processor";
 import { listModels } from "./cli/list-models";
@@ -187,6 +189,59 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 	return undefined;
 }
 
+async function maybeAutoChdir(parsed: Args): Promise<void> {
+	if (parsed.allowHome || parsed.cwd) {
+		return;
+	}
+
+	const home = homedir();
+	if (!home) {
+		return;
+	}
+
+	const normalizePath = (value: string) => {
+		const resolved = resolve(value);
+		return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+	};
+
+	const cwd = normalizePath(process.cwd());
+	const normalizedHome = normalizePath(home);
+	if (cwd !== normalizedHome) {
+		return;
+	}
+
+	const isDirectory = async (path: string) => {
+		try {
+			const stat = await Bun.file(path).stat();
+			return stat.isDirectory();
+		} catch {
+			return false;
+		}
+	};
+
+	const candidates = [join(home, "tmp"), "/tmp", "/var/tmp"];
+	for (const candidate of candidates) {
+		try {
+			if (!(await isDirectory(candidate))) {
+				continue;
+			}
+			process.chdir(candidate);
+			return;
+		} catch {
+			// Try next candidate.
+		}
+	}
+
+	try {
+		const fallback = tmpdir();
+		if (fallback && normalizePath(fallback) !== cwd && (await isDirectory(fallback))) {
+			process.chdir(fallback);
+		}
+	} catch {
+		// Ignore fallback errors.
+	}
+}
+
 /** Discover SYSTEM.md file if no CLI system prompt was provided */
 function discoverSystemPromptFile(): string | undefined {
 	// Check project-local first (.omp/SYSTEM.md, .pi/SYSTEM.md legacy)
@@ -318,6 +373,10 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	const parsed = parseArgs(args);
+	time("parseArgs");
+	await maybeAutoChdir(parsed);
+
 	// Run migrations (pass cwd for project-local migrations)
 	const { migratedAuthProviders: migratedProviders, deprecationWarnings } = await runMigrations(process.cwd());
 
@@ -326,9 +385,6 @@ export async function main(args: string[]) {
 	const modelRegistry = await discoverModels(authStorage);
 	time("discoverModels");
 
-	const parsed = parseArgs(args);
-	time("parseArgs");
-
 	if (parsed.version) {
 		console.log(VERSION);
 		return;

package/src/modes/interactive/components/extensions/extension-dashboard.ts

@@ -38,30 +38,40 @@ export class ExtensionDashboard extends Container {
 	private inspector: InspectorPanel;
 	private settingsManager: SettingsManager | null;
 	private cwd: string;
+	private terminalHeight: number;
 
 	public onClose?: () => void;
 
-	constructor(cwd: string, settingsManager: SettingsManager | null = null) {
+	constructor(cwd: string, settingsManager: SettingsManager | null = null, terminalHeight?: number) {
 		super();
 		this.cwd = cwd;
 		this.settingsManager = settingsManager;
+		this.terminalHeight = terminalHeight ?? process.stdout.rows ?? 24;
 		const disabledIds = settingsManager?.getDisabledExtensions() ?? [];
 		this.state = createInitialState(cwd, disabledIds);
 
+		// Calculate max visible items based on terminal height
+		// Reserve ~10 lines for header, tabs, help text, borders
+		const maxVisible = Math.max(5, Math.floor((this.terminalHeight - 10) / 2));
+
 		// Create main list - always focused
-		this.mainList = new ExtensionList(this.state.searchFiltered, {
-			onSelectionChange: (ext) => {
-				this.state.selected = ext;
-				this.inspector.setExtension(ext);
-			},
-			onToggle: (extensionId, enabled) => {
-				this.handleExtensionToggle(extensionId, enabled);
-			},
-			onMasterToggle: (providerId) => {
-				this.handleProviderToggle(providerId);
+		this.mainList = new ExtensionList(
+			this.state.searchFiltered,
+			{
+				onSelectionChange: (ext) => {
+					this.state.selected = ext;
+					this.inspector.setExtension(ext);
+				},
+				onToggle: (extensionId, enabled) => {
+					this.handleExtensionToggle(extensionId, enabled);
+				},
+				onMasterToggle: (providerId) => {
+					this.handleProviderToggle(providerId);
+				},
+				masterSwitchProvider: this.getActiveProviderId(),
 			},
-			masterSwitchProvider: this.getActiveProviderId(),
-		});
+			maxVisible,
+		);
 		this.mainList.setFocused(true);
 
 		// Create inspector
@@ -91,9 +101,10 @@ export class ExtensionDashboard extends Container {
 		this.addChild(new Text(this.renderTabBar(), 0, 0));
 		this.addChild(new Spacer(1));
 
-		// Help text
-		// 2-column body
-		this.addChild(new TwoColumnBody(this.mainList, this.inspector));
+		// 2-column body with height limit
+		// Reserve ~8 lines for header, tabs, help text, borders
+		const bodyMaxHeight = Math.max(5, this.terminalHeight - 8);
+		this.addChild(new TwoColumnBody(this.mainList, this.inspector, bodyMaxHeight));
 
 		this.addChild(new Spacer(1));
 		this.addChild(new Text(theme.fg("dim", " ↑/↓: navigate  Space: toggle  Tab: next provider  Esc: close"), 0, 0));
@@ -262,10 +273,12 @@ export class ExtensionDashboard extends Container {
 class TwoColumnBody implements Component {
 	private leftPane: ExtensionList;
 	private rightPane: InspectorPanel;
+	private maxHeight: number;
 
-	constructor(left: ExtensionList, right: InspectorPanel) {
+	constructor(left: ExtensionList, right: InspectorPanel, maxHeight: number) {
 		this.leftPane = left;
 		this.rightPane = right;
+		this.maxHeight = maxHeight;
 	}
 
 	render(width: number): string[] {
@@ -275,11 +288,12 @@ class TwoColumnBody implements Component {
 		const leftLines = this.leftPane.render(leftWidth);
 		const rightLines = this.rightPane.render(rightWidth);
 
-		const maxLines = Math.max(leftLines.length, rightLines.length);
+		// Limit to maxHeight lines
+		const numLines = Math.min(this.maxHeight, Math.max(leftLines.length, rightLines.length));
 		const combined: string[] = [];
 		const separator = theme.fg("dim", ` ${theme.boxSharp.vertical} `);
 
-		for (let i = 0; i < maxLines; i++) {
+		for (let i = 0; i < numLines; i++) {
 			const left = truncateToWidth(leftLines[i] ?? "", leftWidth);
 			const leftPadded = left + " ".repeat(Math.max(0, leftWidth - visibleWidth(left)));
 			const right = truncateToWidth(rightLines[i] ?? "", rightWidth);