@oh-my-pi/pi-coding-agent 8.12.10 → 8.13.0

package/src/debug/report-bundle.ts

@@ -0,0 +1,280 @@
+/**
+ * Debug report bundle creation.
+ *
+ * Creates a .tar.gz archive with session data, logs, system info, and optional profiling data.
+ */
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
+import type { CpuProfile, HeapSnapshot } from "./profiler";
+import { collectSystemInfo, sanitizeEnv } from "./system-info";
+
+/** Reports directory path */
+export function getReportsDir(): string {
+	return path.join(os.homedir(), ".omp", "reports");
+}
+
+/** Get today's log file path */
+function getLogPath(): string {
+	const today = new Date().toISOString().slice(0, 10);
+	return path.join(os.homedir(), ".omp", "logs", `omp.${today}.log`);
+}
+
+/** Read last N lines from a file */
+async function readLastLines(filePath: string, n: number): Promise<string> {
+	try {
+		const content = await Bun.file(filePath).text();
+		const lines = content.split("\n");
+		return lines.slice(-n).join("\n");
+	} catch (err) {
+		if (isEnoent(err)) return "";
+		throw err;
+	}
+}
+
+export interface ReportBundleOptions {
+	/** Session file path */
+	sessionFile: string | undefined;
+	/** Settings to include */
+	settings?: Record<string, unknown>;
+	/** CPU profile (for performance reports) */
+	cpuProfile?: CpuProfile;
+	/** Heap snapshot (for memory reports) */
+	heapSnapshot?: HeapSnapshot;
+}
+
+export interface ReportBundleResult {
+	path: string;
+	files: string[];
+}
+
+/**
+ * Create a debug report bundle.
+ *
+ * Bundle contents:
+ * - session.jsonl: Current session transcript
+ * - artifacts/: Session artifacts directory
+ * - subagents/: Subagent sessions + artifacts
+ * - logs.txt: Recent log entries
+ * - system.json: OS, arch, CPU, memory, versions
+ * - env.json: Sanitized environment variables
+ * - config.json: Resolved settings
+ * - profile.cpuprofile: CPU profile (performance report only)
+ * - profile.md: Markdown CPU profile (performance report only)
+ * - heap.heapsnapshot: Heap snapshot (memory report only)
+ */
+export async function createReportBundle(options: ReportBundleOptions): Promise<ReportBundleResult> {
+	const reportsDir = getReportsDir();
+	await fs.mkdir(reportsDir, { recursive: true });
+
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	const outputPath = path.join(reportsDir, `omp-report-${timestamp}.tar.gz`);
+
+	const data: Record<string, string> = {};
+	const files: string[] = [];
+
+	// Collect system info
+	const systemInfo = await collectSystemInfo();
+	data["system.json"] = JSON.stringify(systemInfo, null, 2);
+	files.push("system.json");
+
+	// Sanitized environment
+	data["env.json"] = JSON.stringify(sanitizeEnv(process.env as Record<string, string>), null, 2);
+	files.push("env.json");
+
+	// Settings/config
+	if (options.settings) {
+		data["config.json"] = JSON.stringify(options.settings, null, 2);
+		files.push("config.json");
+	}
+
+	// Recent logs (last 1000 lines)
+	const logPath = getLogPath();
+	const logs = await readLastLines(logPath, 1000);
+	if (logs) {
+		data["logs.txt"] = logs;
+		files.push("logs.txt");
+	}
+
+	// Session file
+	if (options.sessionFile) {
+		try {
+			const sessionContent = await Bun.file(options.sessionFile).text();
+			data["session.jsonl"] = sessionContent;
+			files.push("session.jsonl");
+		} catch {
+			// Session file might not exist yet
+		}
+
+		// Artifacts directory (same path without .jsonl)
+		const artifactsDir = options.sessionFile.slice(0, -6);
+		await addDirectoryToArchive(data, files, artifactsDir, "artifacts");
+
+		// Look for subagent sessions in the same directory
+		const sessionDir = path.dirname(options.sessionFile);
+		const sessionBasename = path.basename(options.sessionFile, ".jsonl");
+		await addSubagentSessions(data, files, sessionDir, sessionBasename);
+	}
+
+	// CPU profile
+	if (options.cpuProfile) {
+		data["profile.cpuprofile"] = options.cpuProfile.data;
+		files.push("profile.cpuprofile");
+		data["profile.md"] = options.cpuProfile.markdown;
+		files.push("profile.md");
+	}
+
+	// Heap snapshot
+	if (options.heapSnapshot) {
+		data["heap.heapsnapshot"] = options.heapSnapshot.data;
+		files.push("heap.heapsnapshot");
+	}
+
+	// Write archive
+	await Bun.Archive.write(outputPath, data, { compress: "gzip" });
+
+	return { path: outputPath, files };
+}
+
+/** Add all files from a directory to the archive */
+async function addDirectoryToArchive(
+	data: Record<string, string>,
+	files: string[],
+	dirPath: string,
+	archivePrefix: string,
+): Promise<void> {
+	try {
+		const entries = await fs.readdir(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isFile()) continue;
+			const filePath = path.join(dirPath, entry.name);
+			const archivePath = `${archivePrefix}/${entry.name}`;
+			try {
+				const content = await Bun.file(filePath).text();
+				data[archivePath] = content;
+				files.push(archivePath);
+			} catch {
+				// Skip files we can't read
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+/** Find and add subagent session files */
+async function addSubagentSessions(
+	data: Record<string, string>,
+	files: string[],
+	sessionDir: string,
+	parentBasename: string,
+): Promise<void> {
+	// Subagent sessions are named with task IDs in the same directory
+	// They follow the pattern: {timestamp}_{sessionId}.jsonl
+	// We look for any sessions created after the parent session
+	try {
+		const entries = await fs.readdir(sessionDir, { withFileTypes: true });
+		const sessionFiles = entries
+			.filter(e => e.isFile() && e.name.endsWith(".jsonl") && e.name !== `${parentBasename}.jsonl`)
+			.map(e => e.name);
+
+		// Limit to most recent 10 subagent sessions
+		const sortedFiles = sessionFiles.sort().slice(-10);
+
+		for (const filename of sortedFiles) {
+			const filePath = path.join(sessionDir, filename);
+			const archivePath = `subagents/${filename}`;
+			try {
+				const content = await Bun.file(filePath).text();
+				data[archivePath] = content;
+				files.push(archivePath);
+
+				// Also add artifacts for this subagent session
+				const artifactsDir = filePath.slice(0, -6);
+				await addDirectoryToArchive(data, files, artifactsDir, `subagents/${filename.slice(0, -6)}`);
+			} catch {
+				// Skip files we can't read
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+/** Get recent log entries for display */
+export async function getRecentLogs(lines: number): Promise<string> {
+	const logPath = getLogPath();
+	return readLastLines(logPath, lines);
+}
+
+/** Calculate total size of artifact cache */
+export async function getArtifactCacheStats(
+	sessionsDir: string,
+): Promise<{ count: number; totalSize: number; oldestDate: Date | null }> {
+	let count = 0;
+	let totalSize = 0;
+	let oldestDate: Date | null = null;
+
+	try {
+		const sessions = await fs.readdir(sessionsDir, { withFileTypes: true });
+
+		for (const session of sessions) {
+			// Artifact directories don't have .jsonl extension
+			if (session.isDirectory()) {
+				const dirPath = path.join(sessionsDir, session.name);
+				try {
+					const stat = await fs.stat(dirPath);
+					const files = await fs.readdir(dirPath);
+					for (const file of files) {
+						const filePath = path.join(dirPath, file);
+						const fileStat = await fs.stat(filePath);
+						if (fileStat.isFile()) {
+							count++;
+							totalSize += fileStat.size;
+						}
+					}
+					if (!oldestDate || stat.mtime < oldestDate) {
+						oldestDate = stat.mtime;
+					}
+				} catch {
+					// Skip inaccessible directories
+				}
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+
+	return { count, totalSize, oldestDate };
+}
+
+/** Clear artifact cache older than N days */
+export async function clearArtifactCache(sessionsDir: string, daysOld: number = 30): Promise<{ removed: number }> {
+	const cutoff = new Date();
+	cutoff.setDate(cutoff.getDate() - daysOld);
+	let removed = 0;
+
+	try {
+		const sessions = await fs.readdir(sessionsDir, { withFileTypes: true });
+
+		for (const session of sessions) {
+			if (session.isDirectory()) {
+				const dirPath = path.join(sessionsDir, session.name);
+				try {
+					const stat = await fs.stat(dirPath);
+					if (stat.mtime < cutoff) {
+						await fs.rm(dirPath, { recursive: true, force: true });
+						removed++;
+					}
+				} catch {
+					// Skip inaccessible directories
+				}
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+
+	return { removed };
+}

package/src/debug/system-info.ts

@@ -0,0 +1,91 @@
+/**
+ * System information collection for debug reports.
+ */
+import * as os from "node:os";
+import { VERSION } from "../config";
+
+export interface SystemInfo {
+	os: string;
+	arch: string;
+	cpu: string;
+	memory: {
+		total: number;
+		free: number;
+	};
+	versions: {
+		app: string;
+		bun: string;
+		node: string;
+	};
+	cwd: string;
+	shell: string;
+	terminal: string | undefined;
+}
+
+/** Collect system information */
+export async function collectSystemInfo(): Promise<SystemInfo> {
+	const cpus = os.cpus();
+	const cpuModel = cpus[0]?.model ?? "Unknown CPU";
+
+	// Try to get shell from environment
+	const shell = process.env.SHELL ?? process.env.ComSpec ?? "unknown";
+	const terminal = process.env.TERM_PROGRAM ?? process.env.TERM ?? undefined;
+
+	return {
+		os: `${os.type()} ${os.release()} (${os.platform()})`,
+		arch: os.arch(),
+		cpu: cpuModel,
+		memory: {
+			total: os.totalmem(),
+			free: os.freemem(),
+		},
+		versions: {
+			app: VERSION,
+			bun: Bun.version,
+			node: process.version,
+		},
+		cwd: process.cwd(),
+		shell,
+		terminal,
+	};
+}
+
+/** Format bytes to human-readable string */
+function formatBytes(bytes: number): string {
+	const gb = bytes / (1024 * 1024 * 1024);
+	return `${gb.toFixed(1)} GB`;
+}
+
+/** Format system info for display */
+export function formatSystemInfo(info: SystemInfo): string {
+	const lines = [
+		"System Information",
+		"━━━━━━━━━━━━━━━━━━",
+		`OS:      ${info.os}`,
+		`Arch:    ${info.arch}`,
+		`CPU:     ${info.cpu}`,
+		`Memory:  ${formatBytes(info.memory.total)} (${formatBytes(info.memory.free)} free)`,
+		`Bun:     ${info.versions.bun}`,
+		`App:     omp ${info.versions.app}`,
+		`Node:    ${info.versions.node} (compat)`,
+		`CWD:     ${info.cwd}`,
+		`Shell:   ${info.shell}`,
+	];
+	if (info.terminal) {
+		lines.push(`Terminal: ${info.terminal}`);
+	}
+	return lines.join("\n");
+}
+
+/** Sanitize environment variables by redacting sensitive values */
+export function sanitizeEnv(env: Record<string, string | undefined>): Record<string, string> {
+	const SENSITIVE_PATTERNS = [/key/i, /secret/i, /token/i, /pass/i, /auth/i, /credential/i, /api/i, /private/i];
+
+	const result: Record<string, string> = {};
+	for (const [k, v] of Object.entries(env)) {
+		if (v === undefined) continue;
+		const isSensitive = SENSITIVE_PATTERNS.some(p => p.test(k));
+		result[k] = isSensitive ? "[REDACTED]" : v;
+	}
+	return result;
+}

package/src/lsp/index.ts

@@ -118,6 +118,7 @@ export async function warmupLspServers(cwd: string, options?: LspWarmupOptions):
 			});
 		} else {
 			const errorMsg = result.reason?.message ?? String(result.reason);
+			logger.warn("LSP server failed to start", { server: name, error: errorMsg });
 			servers.push({
 				name,
 				status: "error",

package/src/main.ts

@@ -87,7 +87,7 @@ async function runInteractiveMode(
 	versionCheckPromise: Promise<string | undefined>,
 	initialMessages: string[],
 	setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
-	lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }> | undefined,
+	lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }> | undefined,
 	mcpManager: import("./mcp").MCPManager | undefined,
 	initialMessage?: string,
 	initialImages?: ImageContent[],

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

@@ -5,7 +5,6 @@ import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
 import { Loader, Markdown, Spacer, Text, visibleWidth } from "@oh-my-pi/pi-tui";
 import { $ } from "bun";
 import { nanoid } from "nanoid";
-import { getDebugLogPath } from "../../config";
 import { loadCustomShare } from "../../export/custom-share";
 import type { CompactOptions } from "../../extensibility/extensions/types";
 import { getGatewayStatus } from "../../ipy/gateway-coordinator";
@@ -266,7 +265,9 @@ export class CommandController {
 			info += `\n${theme.bold("LSP Servers")}\n`;
 			for (const server of this.ctx.lspServers) {
 				const statusColor = server.status === "ready" ? "success" : "error";
-				info += `${theme.fg("dim", `${server.name}:`)} ${theme.fg(statusColor, server.status)} ${theme.fg("dim", `(${server.fileTypes.join(", ")})`)}\n`;
+				const statusText =
+					server.status === "error" && server.error ? `${server.status}: ${server.error}` : server.status;
+				info += `${theme.fg("dim", `${server.name}:`)} ${theme.fg(statusColor, statusText)} ${theme.fg("dim", `(${server.fileTypes.join(", ")})`)}\n`;
 			}
 		}
 
@@ -447,46 +448,6 @@ export class CommandController {
 		this.ctx.ui.requestRender();
 	}
 
-	async handleDebugCommand(): Promise<void> {
-		const width = this.ctx.ui.terminal.columns;
-		const allLines = this.ctx.ui.render(width);
-
-		const debugLogPath = getDebugLogPath();
-		const debugData = [
-			`Debug output at ${new Date().toISOString()}`,
-			`Terminal width: ${width}`,
-			`Total lines: ${allLines.length}`,
-			"",
-			"=== All rendered lines with visible widths ===",
-			...allLines.map((line, idx) => {
-				const vw = visibleWidth(line);
-				const escaped = JSON.stringify(line);
-				return `[${idx}] (w=${vw}) ${escaped}`;
-			}),
-			"",
-			"=== Agent messages (JSONL) ===",
-			...this.ctx.session.messages.map(msg => JSON.stringify(msg)),
-			"",
-		].join("\n");
-
-		try {
-			await Bun.write(debugLogPath, debugData);
-		} catch (error) {
-			this.ctx.showError(`Failed to write debug log: ${error instanceof Error ? error.message : String(error)}`);
-			return;
-		}
-
-		this.ctx.chatContainer.addChild(new Spacer(1));
-		this.ctx.chatContainer.addChild(
-			new Text(
-				`${theme.fg("accent", `${theme.status.success} Debug log written`)}\n${theme.fg("muted", debugLogPath)}`,
-				1,
-				1,
-			),
-		);
-		this.ctx.ui.requestRender();
-	}
-
 	handleArminSaysHi(): void {
 		this.ctx.chatContainer.addChild(new Spacer(1));
 		this.ctx.chatContainer.addChild(new ArminComponent(this.ctx.ui));

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

@@ -64,7 +64,7 @@ export class InputController {
 		this.ctx.editor.onAltP = () => this.ctx.showModelSelector({ temporaryOnly: true });
 
 		// Global debug handler on TUI (works regardless of focus)
-		this.ctx.ui.onDebug = () => void this.ctx.handleDebugCommand();
+		this.ctx.ui.onDebug = () => this.ctx.showDebugSelector();
 		this.ctx.editor.onCtrlL = () => this.ctx.showModelSelector();
 		this.ctx.editor.onCtrlR = () => this.ctx.showHistorySearch();
 		this.ctx.editor.onCtrlT = () => this.ctx.toggleTodoExpansion();
@@ -293,7 +293,7 @@ export class InputController {
 				return;
 			}
 			if (text === "/debug") {
-				void this.ctx.handleDebugCommand();
+				this.ctx.showDebugSelector();
 				this.ctx.editor.setText("");
 				return;
 			}

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

@@ -3,6 +3,7 @@ import type { OAuthProvider } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Input, Loader, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getAgentDbPath } from "../../config";
+import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
 import { AssistantMessageComponent } from "../../modes/components/assistant-message";
 import { ExtensionDashboard } from "../../modes/components/extensions";
@@ -625,4 +626,11 @@ export class SelectorController {
 			return { component: selector, focus: selector };
 		});
 	}
+
+	showDebugSelector(): void {
+		this.showSelector(done => {
+			const selector = new DebugSelectorComponent(this.ctx, done);
+			return { component: selector, focus: selector };
+		});
+	}
 }

package/src/modes/interactive-mode.ts

@@ -134,8 +134,9 @@ export class InteractiveMode implements InteractiveModeContext {
 	private planModePreviousTools: string[] | undefined;
 	private planModePreviousModel: Model<any> | undefined;
 	private planModeHasEntered = false;
-	public readonly lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }> | undefined =
-		undefined;
+	public readonly lspServers:
+		| Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }>
+		| undefined = undefined;
 	public mcpManager?: import("../mcp").MCPManager;
 	private readonly toolUiContextSetter: (uiContext: ExtensionUIContext, hasUI: boolean) => void;
 
@@ -151,7 +152,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		version: string,
 		changelogMarkdown: string | undefined = undefined,
 		setToolUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void = () => {},
-		lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }> | undefined = undefined,
+		lspServers:
+			| Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }>
+			| undefined = undefined,
 		mcpManager?: import("../mcp").MCPManager,
 	) {
 		this.session = session;
@@ -861,8 +864,8 @@ export class InteractiveMode implements InteractiveModeContext {
 		return this.commandController.handleForkCommand();
 	}
 
-	handleDebugCommand(): Promise<void> {
-		return this.commandController.handleDebugCommand();
+	showDebugSelector(): void {
+		this.selectorController.showDebugSelector();
 	}
 
 	handleArminSaysHi(): void {

package/src/modes/types.ts

@@ -51,7 +51,7 @@ export interface InteractiveModeContext {
 	agent: AgentSession["agent"];
 	historyStorage?: HistoryStorage;
 	mcpManager?: MCPManager;
-	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }>;
+	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }>;
 
 	// State
 	isInitialized: boolean;
@@ -144,7 +144,6 @@ export interface InteractiveModeContext {
 	handleDumpCommand(): Promise<void>;
 	handleClearCommand(): Promise<void>;
 	handleForkCommand(): Promise<void>;
-	handleDebugCommand(): Promise<void>;
 	handleArminSaysHi(): void;
 	handleBashCommand(command: string, excludeFromContext?: boolean): Promise<void>;
 	handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
@@ -164,6 +163,7 @@ export interface InteractiveModeContext {
 	handleResumeSession(sessionPath: string): Promise<void>;
 	showOAuthSelector(mode: "login" | "logout"): Promise<void>;
 	showHookConfirm(title: string, message: string): Promise<boolean>;
+	showDebugSelector(): void;
 
 	// Input handling
 	handleCtrlC(): void;

package/src/sdk.ts

@@ -204,7 +204,7 @@ export interface CreateAgentSessionResult {
 	/** Warning if session was restored with a different model than saved */
 	modelFallbackMessage?: string;
 	/** LSP servers that were warmed up at startup */
-	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }>;
+	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }>;
 }
 
 // Re-exports

package/src/session/agent-storage.ts

@@ -138,7 +138,18 @@ export class AgentStorage {
 
 	private constructor(dbPath: string) {
 		this.ensureDir(dbPath);
-		this.db = new Database(dbPath);
+		try {
+			this.db = new Database(dbPath);
+		} catch (err) {
+			const dir = path.dirname(dbPath);
+			const dirExists = fs.existsSync(dir);
+			const errMsg = err instanceof Error ? err.message : String(err);
+			throw new Error(
+				`Failed to open agent database at '${dbPath}': ${errMsg}\n` +
+					`Directory '${dir}' exists: ${dirExists}\n` +
+					`Ensure the directory is writable and not corrupted.`,
+			);
+		}
 
 		this.initializeSchema();
 		this.hardenPermissions(dbPath);
@@ -537,7 +548,20 @@ CREATE TABLE settings (
 	 * @param dbPath - Path to the database file
 	 */
 	private ensureDir(dbPath: string): void {
-		fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+		const dir = path.dirname(dbPath);
+		try {
+			fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+		} catch (err) {
+			const code = (err as NodeJS.ErrnoException).code;
+			// EEXIST is fine - directory already exists
+			if (code !== "EEXIST") {
+				throw new Error(`Failed to create agent storage directory '${dir}': ${code || err}`);
+			}
+		}
+		// Verify directory was created
+		if (!fs.existsSync(dir)) {
+			throw new Error(`Agent storage directory '${dir}' does not exist after creation attempt`);
+		}
 	}
 
 	private hardenPermissions(dbPath: string): void {