lsd-pi 1.1.4 → 1.1.6

package/packages/pi-coding-agent/src/core/pty-executor.ts

@@ -0,0 +1,229 @@
+import { randomBytes } from "node:crypto";
+import { createWriteStream, unlinkSync, type WriteStream } from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { processStreamChunk, type StreamState } from "@gsd/native";
+import { getShellConfig, getShellEnv, sanitizeCommand } from "../utils/shell.js";
+import { DEFAULT_MAX_BYTES, truncateTail } from "./tools/truncate.js";
+import type { BashResult } from "./bash-executor.js";
+
+export interface PtyExecutorOptions {
+	onChunk?: (chunk: string) => void;
+	signal?: AbortSignal;
+	cols?: number;
+	rows?: number;
+	cwd?: string;
+	loginShell?: boolean;
+}
+
+export interface PtyExecutionHandle {
+	pid: number;
+	write(data: string): void;
+	resize(cols: number, rows: number): void;
+	kill(): void;
+	isActive(): boolean;
+}
+
+export interface PtyExecutionSession {
+	handle: PtyExecutionHandle;
+	result: Promise<BashResult>;
+}
+
+type PtyModule = {
+	spawn: (
+		file: string,
+		args?: string[],
+		options?: {
+			name?: string;
+			cols?: number;
+			rows?: number;
+			cwd?: string;
+			env?: Record<string, string>;
+		},
+	) => {
+		pid: number;
+		write(data: string): void;
+		resize(cols: number, rows: number): void;
+		kill(signal?: string): void;
+		onData(cb: (data: string) => void): { dispose(): void } | void;
+		onExit(cb: (event: { exitCode: number; signal?: number }) => void): { dispose(): void } | void;
+	};
+};
+
+const ptyTempFiles = new Set<string>();
+let cleanupRegistered = false;
+
+function registerTempCleanup(): void {
+	if (cleanupRegistered) return;
+	cleanupRegistered = true;
+	process.on("exit", () => {
+		for (const file of ptyTempFiles) {
+			try {
+				unlinkSync(file);
+			} catch {
+				// Best-effort cleanup
+			}
+		}
+	});
+}
+
+export async function loadPtyModule(): Promise<PtyModule | null> {
+	const cjsRequire = createRequire(import.meta.url);
+	for (const name of ["@lydell/node-pty", "node-pty"]) {
+		try {
+			return cjsRequire(name) as PtyModule;
+		} catch {
+			// Try next implementation
+		}
+	}
+	return null;
+}
+
+export async function isPtyAvailable(): Promise<boolean> {
+	return (await loadPtyModule()) !== null;
+}
+
+export async function executeBashInPty(command: string, options: PtyExecutorOptions = {}): Promise<PtyExecutionSession> {
+	const pty = await loadPtyModule();
+	if (!pty) {
+		throw new Error("PTY support is unavailable (install @lydell/node-pty or node-pty)");
+	}
+
+	let shell: string;
+	let args: string[];
+	if (options.loginShell) {
+		shell = process.env.SHELL || "/bin/bash";
+		args = ["-l", "-c"];
+	} else {
+		({ shell, args } = getShellConfig());
+	}
+
+	const child = pty.spawn(shell, [...args, sanitizeCommand(command)], {
+		name: "xterm-256color",
+		cols: Math.max(20, options.cols ?? 80),
+		rows: Math.max(5, options.rows ?? 24),
+		cwd: options.cwd ?? process.cwd(),
+		env: {
+			...Object.fromEntries(
+				Object.entries(getShellEnv()).map(([key, value]) => [key, String(value ?? "")]),
+			),
+			TERM: "xterm-256color",
+		},
+	});
+
+	let active = true;
+	let cancelled = false;
+	const outputChunks: string[] = [];
+	let outputBytes = 0;
+	const maxOutputBytes = DEFAULT_MAX_BYTES * 2;
+	let tempFilePath: string | undefined;
+	let tempFileStream: WriteStream | undefined;
+	let totalBytes = 0;
+	let streamState: StreamState | undefined;
+
+	const handleData = (data: string) => {
+		const buffer = Buffer.from(data, "utf8");
+		totalBytes += buffer.length;
+
+		const result = processStreamChunk(buffer, streamState);
+		streamState = result.state;
+		const text = result.text;
+
+		if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
+			registerTempCleanup();
+			const id = randomBytes(8).toString("hex");
+			tempFilePath = join(tmpdir(), `pi-pty-${id}.log`);
+			ptyTempFiles.add(tempFilePath);
+			tempFileStream = createWriteStream(tempFilePath);
+			for (const chunk of outputChunks) {
+				tempFileStream.write(chunk);
+			}
+		}
+
+		if (tempFileStream) {
+			tempFileStream.write(text);
+		}
+
+		outputChunks.push(text);
+		outputBytes += text.length;
+		while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
+			const removed = outputChunks.shift()!;
+			outputBytes -= removed.length;
+		}
+
+		options.onChunk?.(data);
+	};
+
+	const dataDisposable = child.onData(handleData);
+
+	const result = new Promise<BashResult>((resolve) => {
+		const onAbort = () => {
+			cancelled = true;
+			try {
+				child.kill();
+			} catch {
+				// Best-effort
+			}
+		};
+
+		if (options.signal) {
+			if (options.signal.aborted) {
+				onAbort();
+			} else {
+				options.signal.addEventListener("abort", onAbort, { once: true });
+			}
+		}
+
+		const finish = (exitCode: number | undefined) => {
+			active = false;
+			if (options.signal) {
+				options.signal.removeEventListener("abort", onAbort);
+			}
+			dataDisposable?.dispose?.();
+			tempFileStream?.end();
+
+			const fullOutput = outputChunks.join("");
+			const truncationResult = truncateTail(fullOutput);
+			resolve({
+				output: truncationResult.truncated ? truncationResult.content : fullOutput,
+				exitCode: cancelled ? undefined : exitCode,
+				cancelled,
+				truncated: truncationResult.truncated,
+				fullOutputPath: tempFilePath,
+			});
+		};
+
+		const exitDisposable = child.onExit(({ exitCode }) => {
+			exitDisposable?.dispose?.();
+			finish(exitCode);
+		});
+	});
+
+	return {
+		handle: {
+			pid: child.pid,
+			write(data: string) {
+				if (!active) return;
+				child.write(data);
+			},
+			resize(cols: number, rows: number) {
+				if (!active) return;
+				child.resize(Math.max(20, cols), Math.max(5, rows));
+			},
+			kill() {
+				if (!active) return;
+				cancelled = true;
+				try {
+					child.kill();
+				} catch {
+					// Best-effort
+				}
+			},
+			isActive() {
+				return active;
+			},
+		},
+		result,
+	};
+}

package/packages/pi-coding-agent/src/core/sdk.ts

@@ -254,8 +254,20 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	const editMode = settingsManager.getEditMode();
 	const defaultActiveToolNames: ToolName[] = editMode === "hashline"
-		? ["hashline_read", "bash", "hashline_edit", "write", "lsp"]
-		: ["read", "bash", "edit", "write", "lsp"];
+		? [
+				"hashline_read",
+				"bash",
+				"hashline_edit",
+				"write",
+				"lsp",
+				"pty_start",
+				"pty_send",
+				"pty_read",
+				"pty_wait",
+				"pty_resize",
+				"pty_kill",
+			]
+		: ["read", "bash", "edit", "write", "lsp", "pty_start", "pty_send", "pty_read", "pty_wait", "pty_resize", "pty_kill"];
 	const initialActiveToolNames: ToolName[] = options.tools
 		? options.tools.map((t) => t.name).filter((n): n is ToolName => n in allTools)
 		: defaultActiveToolNames;
@@ -344,8 +356,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			// (e.g., OAuth token refresh failing due to brief connectivity loss).
 			const maxAttempts = 3;
 			const baseDelayMs = 2000;
+			const sid = sessionManager.getSessionId();
 			for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-				const key = await modelRegistry.getApiKeyForProvider(resolvedProvider);
+				const key = await modelRegistry.getApiKeyForProvider(resolvedProvider, sid);
 				if (key) return key;
 
 				// On the last attempt, fall through to error handling below

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -152,6 +152,7 @@ export interface Settings {
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
 	codexRotate?: boolean; // Enable the bundled codex-rotate extension (default: false)
 	cacheTimer?: boolean; // Show elapsed time since last response in the footer (default: true)
+	pinLastPrompt?: boolean; // Pin last sent prompt above the editor as a reminder (default: false)
 	doubleEscapeAction?: "fork" | "tree" | "none"; // Action for double-escape with empty editor (default: "tree")
 	treeFilterMode?: "default" | "no-tools" | "user-only" | "labeled-only" | "all"; // Default filter when opening /tree
 	thinkingBudgets?: ThinkingBudgetsSettings; // Custom token budgets for thinking levels
@@ -175,6 +176,8 @@ export interface Settings {
 	lspInstalledServers?: string[]; // list of server names installed via the onboarding wizard
 	rtk?: boolean; // default: false — enable RTK shell-command compression (requires restart)
 	editorScheme?: "auto" | "vscode" | "cursor" | "zed" | "jetbrains" | "sublime" | "file"; // URI scheme for Cmd+click file links (default: "auto")
+	autoDream?: boolean; // default: false — enable automatic memory consolidation (dream) after sessions
+	autoMemory?: boolean; // default: false — enable automatic memory extraction from session transcripts
 }
 
 function isQualifiedProviderModelRef(value: unknown): value is string {
@@ -1069,6 +1072,14 @@ export class SettingsManager {
 		this.setGlobalSetting("cacheTimer", enabled);
 	}
 
+	getPinLastPrompt(): boolean {
+		return this.settings.pinLastPrompt ?? false;
+	}
+
+	setPinLastPrompt(enabled: boolean): void {
+		this.setGlobalSetting("pinLastPrompt", enabled);
+	}
+
 	getDoubleEscapeAction(): "fork" | "tree" | "none" {
 		return this.settings.doubleEscapeAction ?? "tree";
 	}
@@ -1294,4 +1305,20 @@ export class SettingsManager {
 	setEditorScheme(scheme: "auto" | "vscode" | "cursor" | "zed" | "jetbrains" | "sublime" | "file"): void {
 		this.setGlobalSetting("editorScheme", scheme);
 	}
+
+	getAutoDream(): boolean {
+		return this.settings.autoDream ?? false;
+	}
+
+	setAutoDream(enabled: boolean): void {
+		this.setGlobalSetting("autoDream", enabled);
+	}
+
+	getAutoMemory(): boolean {
+		return this.settings.autoMemory ?? false;
+	}
+
+	setAutoMemory(enabled: boolean): void {
+		this.setGlobalSetting("autoMemory", enabled);
+	}
 }

package/packages/pi-coding-agent/src/core/tool-approval.ts

@@ -1,7 +1,7 @@
 export type PermissionMode = "danger-full-access" | "accept-on-edit" | "auto" | "plan";
 
-export const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls", "lsp", "hashline_read"]);
-export const MUTATING_TOOLS = new Set(["bash", "edit", "write", "hashline_edit"]);
+export const READ_ONLY_TOOLS = new Set(["read", "grep", "find", "ls", "lsp", "hashline_read", "pty_read", "pty_wait"]);
+export const MUTATING_TOOLS = new Set(["bash", "edit", "write", "hashline_edit", "pty_start", "pty_send", "pty_resize", "pty_kill"]);
 
 export interface FileChangeApprovalRequest {
 	action: "write" | "edit" | "delete" | "move";

package/packages/pi-coding-agent/src/core/tools/index.ts

@@ -91,6 +91,17 @@ export {
 	type HashlineReadToolOptions,
 	hashlineReadTool,
 } from "./hashline-read.js";
+export {
+	createPtyTools,
+	type PtyKillInput,
+	type PtyReadInput,
+	type PtyResizeInput,
+	type PtySendInput,
+	type PtyStartInput,
+	type PtyToolDetails,
+	type PtyWaitInput,
+	ptyToolNames,
+} from "./pty.js";
 export {
 	type Anchor,
 	applyHashlineEdits,
@@ -121,6 +132,7 @@ import { createGrepTool, grepTool } from "./grep.js";
 import { createHashlineEditTool, hashlineEditTool } from "./hashline-edit.js";
 import { createHashlineReadTool, hashlineReadTool } from "./hashline-read.js";
 import { createLsTool, lsTool } from "./ls.js";
+import { createPtyTools } from "./pty.js";
 import { createReadTool, type ReadToolOptions, readTool } from "./read.js";
 import { createWriteTool, writeTool } from "./write.js";
 import { createLspTool, lspTool } from "../lsp/index.js";
@@ -134,6 +146,8 @@ export const codingTools: Tool[] = [readTool, bashTool, editTool, writeTool];
 // Read-only tools for exploration without modification (using process.cwd())
 export const readOnlyTools: Tool[] = [readTool, grepTool, findTool, lsTool];
 
+const ptyBuiltinTools = createPtyTools(process.cwd());
+
 // All available tools (using process.cwd())
 export const allTools = {
 	read: readTool,
@@ -146,6 +160,12 @@ export const allTools = {
 	lsp: lspTool,
 	hashline_edit: hashlineEditTool,
 	hashline_read: hashlineReadTool,
+	pty_start: ptyBuiltinTools.pty_start,
+	pty_send: ptyBuiltinTools.pty_send,
+	pty_read: ptyBuiltinTools.pty_read,
+	pty_wait: ptyBuiltinTools.pty_wait,
+	pty_resize: ptyBuiltinTools.pty_resize,
+	pty_kill: ptyBuiltinTools.pty_kill,
 };
 
 // Hashline-mode coding tools — read with hash anchors, edit with hash references
@@ -160,6 +180,19 @@ export interface ToolsOptions {
 	bash?: BashToolOptions;
 }
 
+function addPtyTools<T extends Record<string, Tool>>(target: T, cwd: string): T & Record<string, Tool> {
+	const ptyTools = createPtyTools(cwd);
+	return {
+		...target,
+		pty_start: ptyTools.pty_start,
+		pty_send: ptyTools.pty_send,
+		pty_read: ptyTools.pty_read,
+		pty_wait: ptyTools.pty_wait,
+		pty_resize: ptyTools.pty_resize,
+		pty_kill: ptyTools.pty_kill,
+	};
+}
+
 /**
  * Create coding tools configured for a specific working directory.
  */
@@ -183,7 +216,7 @@ export function createReadOnlyTools(cwd: string, options?: ToolsOptions): Tool[]
  * Create all tools configured for a specific working directory.
  */
 export function createAllTools(cwd: string, options?: ToolsOptions): Record<ToolName, Tool> {
-	return {
+	return addPtyTools({
 		read: createReadTool(cwd, options?.read),
 		bash: createBashTool(cwd, options?.bash),
 		edit: createEditTool(cwd),
@@ -194,7 +227,7 @@ export function createAllTools(cwd: string, options?: ToolsOptions): Record<Tool
 		lsp: createLspTool(cwd),
 		hashline_edit: createHashlineEditTool(cwd),
 		hashline_read: createHashlineReadTool(cwd, options?.read),
-	};
+	}, cwd) as Record<ToolName, Tool>;
 }
 
 /**