@oh-my-pi/pi-coding-agent 3.15.0 → 3.20.0

package/src/modes/interactive/components/bash-execution.ts

@@ -29,12 +29,14 @@ export class BashExecutionComponent extends Container {
 	private contentContainer: Container;
 	private ui: TUI;
 
-	constructor(command: string, ui: TUI) {
+	constructor(command: string, ui: TUI, excludeFromContext = false) {
 		super();
 		this.command = command;
 		this.ui = ui;
 
-		const borderColor = (str: string) => theme.fg("bashMode", str);
+		// Use dim border for excluded-from-context commands (!! prefix)
+		const colorKey = excludeFromContext ? "dim" : "bashMode";
+		const borderColor = (str: string) => theme.fg(colorKey, str);
 
 		// Add spacer
 		this.addChild(new Spacer(1));
@@ -47,13 +49,13 @@ export class BashExecutionComponent extends Container {
 		this.addChild(this.contentContainer);
 
 		// Command header
-		const header = new Text(theme.fg("bashMode", theme.bold(`$ ${command}`)), 1, 0);
+		const header = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
 		this.contentContainer.addChild(header);
 
 		// Loader
 		this.loader = new Loader(
 			ui,
-			(spinner) => theme.fg("bashMode", spinner),
+			(spinner) => theme.fg(colorKey, spinner),
 			(text) => theme.fg("muted", text),
 			`Running${theme.format.ellipsis} (esc to cancel)`,
 			getSymbolTheme().spinnerFrames,

package/src/modes/interactive/components/custom-editor.ts

@@ -1,5 +1,6 @@
 import {
 	Editor,
+	isCapsLock,
 	isCtrlC,
 	isCtrlD,
 	isCtrlG,
@@ -8,10 +9,13 @@ import {
 	isCtrlP,
 	isCtrlT,
 	isCtrlV,
+	isCtrlY,
 	isCtrlZ,
 	isEscape,
 	isShiftCtrlP,
 	isShiftTab,
+	type KeyId,
+	matchesKey,
 } from "@oh-my-pi/pi-tui";
 
 /**
@@ -30,10 +34,41 @@ export class CustomEditor extends Editor {
 	public onCtrlG?: () => void;
 	public onCtrlZ?: () => void;
 	public onQuestionMark?: () => void;
+	public onCapsLock?: () => void;
+	public onCtrlY?: () => void;
 	/** Called when Ctrl+V is pressed. Returns true if handled (image found), false to fall through to text paste. */
 	public onCtrlV?: () => Promise<boolean>;
 
+	/** Custom key handlers from extensions */
+	private customKeyHandlers = new Map<KeyId, () => void>();
+
+	/**
+	 * Register a custom key handler. Extensions use this for shortcuts.
+	 */
+	setCustomKeyHandler(key: KeyId, handler: () => void): void {
+		this.customKeyHandlers.set(key, handler);
+	}
+
+	/**
+	 * Remove a custom key handler.
+	 */
+	removeCustomKeyHandler(key: KeyId): void {
+		this.customKeyHandlers.delete(key);
+	}
+
+	/**
+	 * Clear all custom key handlers.
+	 */
+	clearCustomKeyHandlers(): void {
+		this.customKeyHandlers.clear();
+	}
+
 	handleInput(data: string): void {
+		if (isCapsLock(data) && this.onCapsLock) {
+			this.onCapsLock();
+			return;
+		}
+
 		// Intercept Ctrl+V for image paste (async - fires and handles result)
 		if (isCtrlV(data) && this.onCtrlV) {
 			void this.onCtrlV();
@@ -46,6 +81,12 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		// Intercept Ctrl+Y for voice input
+		if (isCtrlY(data) && this.onCtrlY) {
+			this.onCtrlY();
+			return;
+		}
+
 		// Intercept Ctrl+Z for suspend
 		if (isCtrlZ(data) && this.onCtrlZ) {
 			this.onCtrlZ();
@@ -58,6 +99,12 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		// Intercept Ctrl+Y for role-based model cycling
+		if (isCtrlY(data) && this.onCtrlY) {
+			this.onCtrlY();
+			return;
+		}
+
 		// Intercept Ctrl+L for model selector
 		if (isCtrlL(data) && this.onCtrlL) {
 			this.onCtrlL();
@@ -116,6 +163,14 @@ export class CustomEditor extends Editor {
 			return;
 		}
 
+		// Check custom key handlers (extensions)
+		for (const [keyId, handler] of this.customKeyHandlers) {
+			if (matchesKey(data, keyId)) {
+				handler();
+				return;
+			}
+		}
+
 		// Pass to parent for normal handling
 		super.handleInput(data);
 	}

package/src/modes/interactive/components/custom-message.ts

@@ -0,0 +1,95 @@
+import type { TextContent } from "@oh-my-pi/pi-ai";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Box, Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
+import type { MessageRenderer } from "../../../core/extensions/types";
+import type { CustomMessage } from "../../../core/messages";
+import { getMarkdownTheme, theme } from "../theme/theme";
+
+/**
+ * Component that renders a custom message entry from extensions.
+ * Uses distinct styling to differentiate from user messages.
+ */
+export class CustomMessageComponent extends Container {
+	private message: CustomMessage<unknown>;
+	private customRenderer?: MessageRenderer;
+	private box: Box;
+	private customComponent?: Component;
+	private _expanded = false;
+
+	constructor(message: CustomMessage<unknown>, customRenderer?: MessageRenderer) {
+		super();
+		this.message = message;
+		this.customRenderer = customRenderer;
+
+		this.addChild(new Spacer(1));
+
+		// Create box with custom background (used for default rendering)
+		this.box = new Box(1, 1, (t) => theme.bg("customMessageBg", t));
+
+		this.rebuild();
+	}
+
+	setExpanded(expanded: boolean): void {
+		if (this._expanded !== expanded) {
+			this._expanded = expanded;
+			this.rebuild();
+		}
+	}
+
+	private rebuild(): void {
+		// Remove previous content component
+		if (this.customComponent) {
+			this.removeChild(this.customComponent);
+			this.customComponent = undefined;
+		}
+		this.removeChild(this.box);
+
+		// Try custom renderer first - it handles its own styling
+		if (this.customRenderer) {
+			try {
+				const component = this.customRenderer(this.message, { expanded: this._expanded }, theme);
+				if (component) {
+					this.customComponent = component;
+					this.addChild(component);
+					return;
+				}
+			} catch {
+				// Fall through to default rendering
+			}
+		}
+
+		// Default rendering uses our box
+		this.addChild(this.box);
+		this.box.clear();
+
+		// Default rendering: label + content
+		const label = theme.fg("customMessageLabel", theme.bold(`[${this.message.customType}]`));
+		this.box.addChild(new Text(label, 0, 0));
+		this.box.addChild(new Spacer(1));
+
+		// Extract text content
+		let text: string;
+		if (typeof this.message.content === "string") {
+			text = this.message.content;
+		} else {
+			text = this.message.content
+				.filter((c): c is TextContent => c.type === "text")
+				.map((c) => c.text)
+				.join("\n");
+		}
+
+		// Limit lines when collapsed
+		if (!this._expanded) {
+			const lines = text.split("\n");
+			if (lines.length > 5) {
+				text = `${lines.slice(0, 5).join("\n")}\n${theme.format.ellipsis}`;
+			}
+		}
+
+		this.box.addChild(
+			new Markdown(text, 0, 0, getMarkdownTheme(), {
+				color: (value: string) => theme.fg("customMessageText", value),
+			}),
+		);
+	}
+}

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

@@ -230,6 +230,8 @@ export class ExtensionList implements Component {
 
 	private getKindIcon(kind: ExtensionKind): string {
 		switch (kind) {
+			case "extension-module":
+				return theme.icon.extensionTool;
 			case "skill":
 				return theme.icon.extensionSkill;
 			case "tool":
@@ -316,6 +318,7 @@ export class ExtensionList implements Component {
 		}
 
 		const kindOrder: ExtensionKind[] = [
+			"extension-module",
 			"skill",
 			"tool",
 			"slash-command",
@@ -347,6 +350,8 @@ export class ExtensionList implements Component {
 
 	private getKindLabel(kind: ExtensionKind): string {
 		switch (kind) {
+			case "extension-module":
+				return "Extension Modules";
 			case "skill":
 				return "Skills";
 			case "tool":

package/src/modes/interactive/components/extensions/inspector-panel.ts

@@ -4,7 +4,6 @@
  * Shows name, description, origin, status, and kind-specific preview.
  */
 
-import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { type Component, truncateToWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import { theme } from "../../theme/theme";
@@ -98,16 +97,22 @@ export class InspectorPanel implements Component {
 		lines.push(theme.fg("dim", theme.boxSharp.horizontal.repeat(Math.min(width - 2, 40))));
 
 		try {
-			const content = readFileSync(path, "utf-8");
-			const fileLines = content.split("\n").slice(0, 20);
-
-			for (const line of fileLines) {
-				const highlighted = this.highlightMarkdown(line);
-				lines.push(truncateToWidth(highlighted, width - 2));
-			}
-
-			if (content.split("\n").length > 20) {
-				lines.push(theme.fg("dim", "(truncated at line 20)"));
+			const content = Bun.file(path).text();
+			// Note: async call to sync context - will show empty on first render
+			// This is acceptable for preview which can populate on next render
+			if (typeof content === "object" && "then" in content) {
+				content.then((text: string) => {
+					const fileLines = text.split("\n").slice(0, 20);
+
+					for (const line of fileLines) {
+						const highlighted = this.highlightMarkdown(line);
+						lines.push(truncateToWidth(highlighted, width - 2));
+					}
+
+					if (text.split("\n").length > 20) {
+						lines.push(theme.fg("dim", "(truncated at line 20)"));
+					}
+				});
 			}
 		} catch (err) {
 			lines.push(theme.fg("error", `Failed to read file: ${err instanceof Error ? err.message : String(err)}`));
@@ -261,6 +266,7 @@ export class InspectorPanel implements Component {
 
 	private getKindBadge(kind: string): string {
 		const kindColors: Record<string, string> = {
+			"extension-module": "accent",
 			skill: "accent",
 			rule: "success",
 			tool: "warning",
@@ -296,7 +302,7 @@ export class InspectorPanel implements Component {
 
 	private shortenPath(path: string): string {
 		const home = homedir();
-		if (path.startsWith(home)) {
+		if (home && path.startsWith(home)) {
 			return `~${path.slice(home.length)}`;
 		}
 

package/src/modes/interactive/components/extensions/state-manager.ts

@@ -4,6 +4,7 @@
  */
 
 import type { ContextFile } from "../../../../capability/context-file";
+import type { ExtensionModule } from "../../../../capability/extension-module";
 import type { Hook } from "../../../../capability/hook";
 import type { MCPServer } from "../../../../capability/mcp";
 import type { Prompt } from "../../../../capability/prompt";
@@ -128,6 +129,15 @@ export function loadAllExtensions(cwd?: string, disabledIds?: string[]): Extensi
 		// Capability may not be registered
 	}
 
+	// Load extension modules
+	try {
+		const modules = loadSync<ExtensionModule>("extension-modules", loadOpts);
+		const nativeModules = modules.all.filter((module) => module._source.provider === "native");
+		addItems(nativeModules, "extension-module");
+	} catch {
+		// Capability may not be registered
+	}
+
 	// Load MCP servers
 	try {
 		const mcps = loadSync<MCPServer>("mcps", loadOpts);
@@ -394,6 +404,8 @@ export function applyFilter(extensions: Extension[], query: string): Extension[]
  */
 function getKindDisplayName(kind: ExtensionKind): string {
 	switch (kind) {
+		case "extension-module":
+			return "Extension Modules";
 		case "skill":
 			return "Skills";
 		case "rule":

package/src/modes/interactive/components/extensions/types.ts

@@ -8,6 +8,7 @@ import type { SourceMeta } from "../../../../capability/types";
  * Extension kinds matching capability types.
  */
 export type ExtensionKind =
+	| "extension-module"
 	| "skill"
 	| "rule"
 	| "tool"

package/src/modes/interactive/components/footer.ts

@@ -0,0 +1,324 @@
+import { existsSync, type FSWatcher, readFileSync, watch } from "node:fs";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
+import { dirname, join } from "path";
+import type { AgentSession } from "../../../core/agent-session";
+import { theme } from "../theme/theme";
+
+/**
+ * Sanitize text for display in a single-line status.
+ * Removes newlines, tabs, carriage returns, and other control characters.
+ */
+function sanitizeStatusText(text: string): string {
+	// Replace newlines, tabs, carriage returns with space, then collapse multiple spaces
+	return text
+		.replace(/[\r\n\t]/g, " ")
+		.replace(/ +/g, " ")
+		.trim();
+}
+
+/**
+ * Find the git root directory by walking up from cwd.
+ * Returns the path to .git/HEAD if found, null otherwise.
+ */
+function findGitHeadPath(): string | null {
+	let dir = process.cwd();
+	while (true) {
+		const gitHeadPath = join(dir, ".git", "HEAD");
+		if (existsSync(gitHeadPath)) {
+			return gitHeadPath;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) {
+			// Reached filesystem root
+			return null;
+		}
+		dir = parent;
+	}
+}
+
+/**
+ * Footer component that shows pwd, token stats, and context usage
+ */
+export class FooterComponent implements Component {
+	private session: AgentSession;
+	private cachedBranch: string | null | undefined = undefined; // undefined = not checked yet, null = not in git repo, string = branch name
+	private gitWatcher: FSWatcher | null = null;
+	private onBranchChange: (() => void) | null = null;
+	private autoCompactEnabled: boolean = true;
+	private extensionStatuses: Map<string, string> = new Map();
+
+	constructor(session: AgentSession) {
+		this.session = session;
+	}
+
+	setAutoCompactEnabled(enabled: boolean): void {
+		this.autoCompactEnabled = enabled;
+	}
+
+	/**
+	 * Set extension status text to display in the footer.
+	 * Text is sanitized (newlines/tabs replaced with spaces) and truncated to terminal width.
+	 * ANSI escape codes for styling are preserved.
+	 * @param key - Unique key to identify this status
+	 * @param text - Status text, or undefined to clear
+	 */
+	setExtensionStatus(key: string, text: string | undefined): void {
+		if (text === undefined) {
+			this.extensionStatuses.delete(key);
+		} else {
+			this.extensionStatuses.set(key, text);
+		}
+	}
+
+	/**
+	 * Set up a file watcher on .git/HEAD to detect branch changes.
+	 * Call the provided callback when branch changes.
+	 */
+	watchBranch(onBranchChange: () => void): void {
+		this.onBranchChange = onBranchChange;
+		this.setupGitWatcher();
+	}
+
+	private setupGitWatcher(): void {
+		// Clean up existing watcher
+		if (this.gitWatcher) {
+			this.gitWatcher.close();
+			this.gitWatcher = null;
+		}
+
+		const gitHeadPath = findGitHeadPath();
+		if (!gitHeadPath) {
+			return;
+		}
+
+		try {
+			this.gitWatcher = watch(gitHeadPath, () => {
+				this.cachedBranch = undefined; // Invalidate cache
+				if (this.onBranchChange) {
+					this.onBranchChange();
+				}
+			});
+		} catch {
+			// Silently fail if we can't watch
+		}
+	}
+
+	/**
+	 * Clean up the file watcher
+	 */
+	dispose(): void {
+		if (this.gitWatcher) {
+			this.gitWatcher.close();
+			this.gitWatcher = null;
+		}
+	}
+
+	invalidate(): void {
+		// Invalidate cached branch so it gets re-read on next render
+		this.cachedBranch = undefined;
+	}
+
+	/**
+	 * Get current git branch by reading .git/HEAD directly.
+	 * Returns null if not in a git repo, branch name otherwise.
+	 */
+	private getCurrentBranch(): string | null {
+		// Return cached value if available
+		if (this.cachedBranch !== undefined) {
+			return this.cachedBranch;
+		}
+
+		try {
+			const gitHeadPath = findGitHeadPath();
+			if (!gitHeadPath) {
+				this.cachedBranch = null;
+				return null;
+			}
+			const content = readFileSync(gitHeadPath, "utf8").trim();
+
+			if (content.startsWith("ref: refs/heads/")) {
+				// Normal branch: extract branch name
+				this.cachedBranch = content.slice(16);
+			} else {
+				// Detached HEAD state
+				this.cachedBranch = "detached";
+			}
+		} catch {
+			// Not in a git repo or error reading file
+			this.cachedBranch = null;
+		}
+
+		return this.cachedBranch;
+	}
+
+	render(width: number): string[] {
+		const state = this.session.state;
+
+		// Calculate cumulative usage from ALL session entries (not just post-compaction messages)
+		let totalInput = 0;
+		let totalOutput = 0;
+		let totalCacheRead = 0;
+		let totalCacheWrite = 0;
+		let totalCost = 0;
+
+		for (const entry of this.session.sessionManager.getEntries()) {
+			if (entry.type === "message" && entry.message.role === "assistant") {
+				totalInput += entry.message.usage.input;
+				totalOutput += entry.message.usage.output;
+				totalCacheRead += entry.message.usage.cacheRead;
+				totalCacheWrite += entry.message.usage.cacheWrite;
+				totalCost += entry.message.usage.cost.total;
+			}
+		}
+
+		// Get last assistant message for context percentage calculation (skip aborted messages)
+		const lastAssistantMessage = state.messages
+			.slice()
+			.reverse()
+			.find((m) => m.role === "assistant" && m.stopReason !== "aborted") as AssistantMessage | undefined;
+
+		// Calculate context percentage from last message (input + output + cacheRead + cacheWrite)
+		const contextTokens = lastAssistantMessage
+			? lastAssistantMessage.usage.input +
+				lastAssistantMessage.usage.output +
+				lastAssistantMessage.usage.cacheRead +
+				lastAssistantMessage.usage.cacheWrite
+			: 0;
+		const contextWindow = state.model?.contextWindow || 0;
+		const contextPercentValue = contextWindow > 0 ? (contextTokens / contextWindow) * 100 : 0;
+		const contextPercent = contextPercentValue.toFixed(1);
+
+		// Format token counts (similar to web-ui)
+		const formatTokens = (count: number): string => {
+			if (count < 1000) return count.toString();
+			if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+			if (count < 1000000) return `${Math.round(count / 1000)}k`;
+			if (count < 10000000) return `${(count / 1000000).toFixed(1)}M`;
+			return `${Math.round(count / 1000000)}M`;
+		};
+
+		// Replace home directory with ~
+		let pwd = process.cwd();
+		const home = process.env.HOME || process.env.USERPROFILE;
+		if (home && pwd.startsWith(home)) {
+			pwd = `~${pwd.slice(home.length)}`;
+		}
+
+		// Add git branch if available
+		const branch = this.getCurrentBranch();
+		if (branch) {
+			pwd = `${pwd} (${branch})`;
+		}
+
+		// Truncate path if too long to fit width
+		if (pwd.length > width) {
+			const half = Math.floor(width / 2) - 2;
+			if (half > 0) {
+				const start = pwd.slice(0, half);
+				const end = pwd.slice(-(half - 1));
+				pwd = `${start}...${end}`;
+			} else {
+				pwd = pwd.slice(0, Math.max(1, width));
+			}
+		}
+
+		// Build stats line
+		const statsParts = [];
+		if (totalInput) statsParts.push(`↑${formatTokens(totalInput)}`);
+		if (totalOutput) statsParts.push(`↓${formatTokens(totalOutput)}`);
+		if (totalCacheRead) statsParts.push(`R${formatTokens(totalCacheRead)}`);
+		if (totalCacheWrite) statsParts.push(`W${formatTokens(totalCacheWrite)}`);
+
+		// Show cost with "(sub)" indicator if using OAuth subscription
+		const usingSubscription = state.model ? this.session.modelRegistry.isUsingOAuth(state.model) : false;
+		if (totalCost || usingSubscription) {
+			const costStr = `$${totalCost.toFixed(3)}${usingSubscription ? " (sub)" : ""}`;
+			statsParts.push(costStr);
+		}
+
+		// Colorize context percentage based on usage
+		let contextPercentStr: string;
+		const autoIndicator = this.autoCompactEnabled ? " (auto)" : "";
+		const contextPercentDisplay = `${contextPercent}%/${formatTokens(contextWindow)}${autoIndicator}`;
+		if (contextPercentValue > 90) {
+			contextPercentStr = theme.fg("error", contextPercentDisplay);
+		} else if (contextPercentValue > 70) {
+			contextPercentStr = theme.fg("warning", contextPercentDisplay);
+		} else {
+			contextPercentStr = contextPercentDisplay;
+		}
+		statsParts.push(contextPercentStr);
+
+		let statsLeft = statsParts.join(" ");
+
+		// Add model name on the right side, plus thinking level if model supports it
+		const modelName = state.model?.id || "no-model";
+
+		// Add thinking level hint if model supports reasoning and thinking is enabled
+		let rightSide = modelName;
+		if (state.model?.reasoning) {
+			const thinkingLevel = state.thinkingLevel || "off";
+			if (thinkingLevel !== "off") {
+				rightSide = `${modelName} • ${thinkingLevel}`;
+			}
+		}
+
+		let statsLeftWidth = visibleWidth(statsLeft);
+		const rightSideWidth = visibleWidth(rightSide);
+
+		// If statsLeft is too wide, truncate it
+		if (statsLeftWidth > width) {
+			// Truncate statsLeft to fit width (no room for right side)
+			const plainStatsLeft = statsLeft.replace(/\x1b\[[0-9;]*m/g, "");
+			statsLeft = `${plainStatsLeft.substring(0, width - 3)}...`;
+			statsLeftWidth = visibleWidth(statsLeft);
+		}
+
+		// Calculate available space for padding (minimum 2 spaces between stats and model)
+		const minPadding = 2;
+		const totalNeeded = statsLeftWidth + minPadding + rightSideWidth;
+
+		let statsLine: string;
+		if (totalNeeded <= width) {
+			// Both fit - add padding to right-align model
+			const padding = " ".repeat(width - statsLeftWidth - rightSideWidth);
+			statsLine = statsLeft + padding + rightSide;
+		} else {
+			// Need to truncate right side
+			const availableForRight = width - statsLeftWidth - minPadding;
+			if (availableForRight > 3) {
+				// Truncate to fit (strip ANSI codes for length calculation, then truncate raw string)
+				const plainRightSide = rightSide.replace(/\x1b\[[0-9;]*m/g, "");
+				const truncatedPlain = plainRightSide.substring(0, availableForRight);
+				// For simplicity, just use plain truncated version (loses color, but fits)
+				const padding = " ".repeat(width - statsLeftWidth - truncatedPlain.length);
+				statsLine = statsLeft + padding + truncatedPlain;
+			} else {
+				// Not enough space for right side at all
+				statsLine = statsLeft;
+			}
+		}
+
+		// Apply dim to each part separately. statsLeft may contain color codes (for context %)
+		// that end with a reset, which would clear an outer dim wrapper. So we dim the parts
+		// before and after the colored section independently.
+		const dimStatsLeft = theme.fg("dim", statsLeft);
+		const remainder = statsLine.slice(statsLeft.length); // padding + rightSide
+		const dimRemainder = theme.fg("dim", remainder);
+
+		const lines = [theme.fg("dim", pwd), dimStatsLeft + dimRemainder];
+
+		// Add extension statuses on a single line, sorted by key alphabetically
+		if (this.extensionStatuses.size > 0) {
+			const sortedStatuses = Array.from(this.extensionStatuses.entries())
+				.sort(([a], [b]) => a.localeCompare(b))
+				.map(([, text]) => sanitizeStatusText(text));
+			const statusLine = sortedStatuses.join(" ");
+			// Truncate to terminal width with dim ellipsis for consistency with footer style
+			lines.push(truncateToWidth(statusLine, width, theme.fg("dim", "...")));
+		}
+
+		return lines;
+	}
+}

package/src/modes/interactive/components/hook-editor.ts

@@ -39,6 +39,7 @@ export class HookEditorComponent extends Container {
 
 		// Create editor
 		this.editor = new Editor(getEditorTheme());
+		this.editor.setUseTerminalCursor(true);
 		if (prefill) {
 			this.editor.setText(prefill);
 		}