@dyyz1993/pi-coding-agent 0.74.27 → 0.74.29

package/dist/extensions/bash-ext/index.ts

@@ -73,6 +73,7 @@ type BashToolDetails = _BashToolDetails & {
 };
 
 const DEFAULT_TIMEOUT_SECONDS = 300;
+const DEFAULT_BACKGROUND_AFTER_SECONDS = 120;
 
 const bashSchema = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
@@ -179,83 +180,105 @@ export default function (pi: ExtensionAPI) {
 		});
 
 		channel.handle("kill", ({ toolCallId }) => {
-			if (!toolCallId) return;
+			if (!toolCallId) return { ok: false, reason: "not_found" };
 			const m = managed.get(toolCallId);
-			if (m?.proc.pid) {
-				killProcessTree(m.proc.pid);
-				m.proc.status = "terminated";
-				m.proc.endedAt = Date.now();
-				m.resolved = true;
-				m.killedByUser = true;
-				const durationMs = m.proc.endedAt - m.proc.startedAt;
-				if (m.logStream) m.logStream.end();
+			if (!m) {
+				// Process already exited — emit terminated event so frontend can sync state
 				channel?.emit("terminated", {
 					type: "terminated",
 					toolCallId,
-					pid: m.proc.pid,
+					pid: undefined,
 					processes: Array.from(managed.values()).map((x) => x.proc),
 					timestamp: Date.now(),
 				});
-				m.resolve({
-					content: [
-						{
-							type: "text",
-							text: `${m.proc.output || "(no output)"}\n\n[User cancelled after ${formatDuration(durationMs)}, PID: ${m.proc.pid}${m.proc.logPath ? `. Log: ${m.proc.logPath}` : ""}]`,
-						},
-					],
-					details: {
-						terminated: {
-							reason: "user_cancel",
-							pid: m.proc.pid,
-							command: m.proc.command,
-							startedAt: m.proc.startedAt,
-							endedAt: m.proc.endedAt,
-							durationMs,
-							logPath: m.proc.logPath,
-						},
-					},
-				});
+				return { ok: true, alreadyExited: true };
 			}
+			if (m.proc.pid) {
+				killProcessTree(m.proc.pid);
+			}
+			m.proc.status = "terminated";
+			m.proc.endedAt = Date.now();
+			m.resolved = true;
+			m.killedByUser = true;
+			const durationMs = m.proc.endedAt - m.proc.startedAt;
+			if (m.logStream) m.logStream.end();
+			channel?.emit("terminated", {
+				type: "terminated",
+				toolCallId,
+				pid: m.proc.pid,
+				processes: Array.from(managed.values()).map((x) => x.proc),
+				timestamp: Date.now(),
+			});
+			m.resolve({
+				content: [
+					{
+						type: "text",
+						text: `${m.proc.output || "(no output)"}\n\n[User cancelled after ${formatDuration(durationMs)}, PID: ${m.proc.pid ?? "unknown"}${m.proc.logPath ? `. Log: ${m.proc.logPath}` : ""}]`,
+					},
+				],
+				details: {
+					terminated: {
+						reason: "user_cancel",
+						pid: m.proc.pid,
+						command: m.proc.command,
+						startedAt: m.proc.startedAt,
+						endedAt: m.proc.endedAt,
+						durationMs,
+						logPath: m.proc.logPath,
+					},
+				},
+			});
+			return { ok: true };
 		});
 
 		channel.handle("background", ({ toolCallId }) => {
-			if (!toolCallId) return;
+			if (!toolCallId) return { ok: false, reason: "not_found" };
 			const m = managed.get(toolCallId);
-			if (m) {
-				m.proc.status = "background";
-				m.resolved = true;
-				m.backgrounded = true;
-				m.outputSubscribed = false;
-				createLogStream(m);
-				const durationMs = Date.now() - m.proc.startedAt;
-				channel?.emit("background", {
-					type: "background",
+			if (!m) {
+				// Process already exited — emit terminated event so frontend can sync state
+				channel?.emit("terminated", {
+					type: "terminated",
 					toolCallId,
-					pid: m.proc.pid,
-					data: m.proc.output.slice(-2000),
+					pid: undefined,
 					processes: Array.from(managed.values()).map((x) => x.proc),
 					timestamp: Date.now(),
 				});
-						const outputPreview = m.proc.output ? takeLastLines(m.proc.output, BG_PREVIEW_LINES) : "(no output yet)";
-						m.resolve({
-							content: [
-								{
-									type: "text",
-									text: `${outputPreview}\n\n[Moved to background after ${formatDuration(durationMs)}, PID: ${m.proc.pid ?? "unknown"}. <bashId>${m.proc.bashId}</bashId>. Log: ${m.proc.logPath}. Use get_background_process with <bashId>${m.proc.bashId}</bashId> to check progress.]`,
-								},
-							],
-					details: {
-						background: {
-							pid: m.proc.pid,
-							command: m.proc.command,
-							startedAt: m.proc.startedAt,
-							durationMs,
-							logPath: m.proc.logPath,
-							detached: false,
-						},
-					},
-				});
+				return { ok: true, alreadyExited: true };
 			}
+			m.proc.status = "background";
+			m.resolved = true;
+			m.backgrounded = true;
+			m.outputSubscribed = false;
+			createLogStream(m);
+			const durationMs = Date.now() - m.proc.startedAt;
+			channel?.emit("background", {
+				type: "background",
+				toolCallId,
+				pid: m.proc.pid,
+				data: m.proc.output.slice(-2000),
+				processes: Array.from(managed.values()).map((x) => x.proc),
+				timestamp: Date.now(),
+			});
+			const outputPreview = m.proc.output ? takeLastLines(m.proc.output, BG_PREVIEW_LINES) : "(no output yet)";
+			m.resolve({
+				content: [
+					{
+						type: "text",
+						text: `${outputPreview}\n\n[Moved to background after ${formatDuration(durationMs)}, PID: ${m.proc.pid ?? "unknown"}. <bashId>${m.proc.bashId}</bashId>. Log: ${m.proc.logPath}. Use get_background_process with <bashId>${m.proc.bashId}</bashId> to check progress.]`,
+					},
+				],
+				details: {
+					background: {
+						pid: m.proc.pid,
+						command: m.proc.command,
+						startedAt: m.proc.startedAt,
+						durationMs,
+						logPath: m.proc.logPath,
+						detached: false,
+					},
+				},
+			});
+			return { ok: true };
 		});
 
 		channel.handle("subscribe_output", ({ toolCallId }) => {
@@ -318,8 +341,9 @@ export default function (pi: ExtensionAPI) {
 			_ctx?: ExtensionContext,
 		): Promise<AgentToolResult<BashToolDetails>> {
 			return new Promise((resolve, reject) => {
-				const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT_SECONDS;
-				const effectiveBackgroundAfter = backgroundAfter !== undefined && backgroundAfter < effectiveTimeout ? backgroundAfter : undefined;
+			const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT_SECONDS;
+			const rawBackgroundAfter = backgroundAfter ?? DEFAULT_BACKGROUND_AFTER_SECONDS;
+			const effectiveBackgroundAfter = rawBackgroundAfter < effectiveTimeout ? rawBackgroundAfter : undefined;
 				const cwd = cwdParam ?? _ctx?.cwd ?? process.cwd();
 				const bashId = generateBashId();
 

package/dist/extensions/file-snapshot/index.ts

@@ -4,7 +4,10 @@ export default function fileSnapshot(pi: ExtensionAPI) {
 	const channel = pi.registerChannel("file-snapshot");
 
 	channel.onReceive(async (msg) => {
-		const ctx = msg.context as ExtensionContext;
+		const ctx = msg.context as ExtensionContext | undefined;
+		if (!ctx) {
+			return { error: "Extension context not available in channel message. This operation is not supported via RPC client channel calls." };
+		}
 		const mgr = ctx.fileSnapshotManager;
 		if (!mgr) {
 			return { error: "fileSnapshotManager not available" };

package/dist/extensions/hooks-engine/index.ts

@@ -7,7 +7,7 @@
  * Supported events: tool_call, tool_result, agent_start, agent_end
  * Supported hook types: command (spawn process), prompt (inject text)
  *
- * Command hooks: exit code 2 = block operation, 0 = allow
+ * Command hooks: exit code 2 = block operation, 0 = allow, 3 = ask user
  * Prompt hooks: text injected into the conversation
  */
 
@@ -23,7 +23,18 @@ const EVENT_MAP: Record<string, string> = {
 	session_shutdown: "on_session_end",
 };
 
-function parseHooks(raw: string | undefined): AgentHooks | null {
+// Export types for testing
+export type { HookResult };
+
+interface HookResult {
+	action: "allow" | "deny" | "ask";
+	reason?: string;
+	question?: string;
+	options?: string[];
+	message?: string;
+}
+
+export function parseHooks(raw: string | undefined): AgentHooks | null {
 	if (!raw) return null;
 	try {
 		return JSON.parse(raw);
@@ -32,21 +43,38 @@ function parseHooks(raw: string | undefined): AgentHooks | null {
 	}
 }
 
-function matchesCondition(condition: string | undefined, event: Record<string, unknown>): boolean {
+export function matchesCondition(condition: string | undefined, event: Record<string, unknown>): boolean {
 	if (!condition) return true;
 	const toolName = (event.toolName as string) ?? "";
-	const parts = condition.split("|").map(s => s.trim());
+	const parts = condition.split("|").map((s) => s.trim());
 	return parts.includes(toolName);
 }
 
-async function executeCommand(command: string, event: Record<string, unknown>, timeout = 5000): Promise<number> {
+export async function executeCommand(
+	command: string,
+	event: Record<string, unknown>,
+	timeout = 5000,
+): Promise<{ exitCode: number; stdout: string }> {
 	return new Promise((resolve) => {
 		const toolName = (event.toolName as string) ?? "";
+		const toolCallId = (event.toolCallId as string) ?? "";
 		const input = event.input ?? {};
+		const vars = event.variables as Record<string, string> | undefined;
+
 		const env: Record<string, string> = {
 			...process.env as Record<string, string>,
+			// Tool context
 			PI_HOOK_TOOL: toolName,
-			PI_HOOK_EVENT: JSON.stringify(input),
+			PI_HOOK_TOOL_CALL_ID: toolCallId,
+			PI_HOOK_INPUT: JSON.stringify(input),
+			// Agent context (from event.variables)
+			PI_HOOK_AGENT_NAME: vars?.agentName ?? "",
+			PI_HOOK_PERMISSION_MODE: vars?.permissionMode ?? "",
+			PI_HOOK_ALLOWED_TOOLS: vars?.allowedTools ?? "",
+			PI_HOOK_DISALLOWED_TOOLS: vars?.disallowedTools ?? "",
+			// Session context (if available)
+			PI_HOOK_SESSION_ID: (event as any).sessionId ?? "",
+			PI_HOOK_CWD: (event as any).cwd ?? "",
 		};
 
 		const proc = spawn("sh", ["-c", command], {
@@ -54,29 +82,52 @@ async function executeCommand(command: string, event: Record<string, unknown>, t
 			stdio: ["pipe", "pipe", "pipe"],
 		});
 
+		let stdout = "";
+		let stderr = "";
+
+		proc.stdout?.on("data", (data) => {
+			stdout += String(data);
+		});
+
+		proc.stderr?.on("data", (data) => {
+			stderr += String(data);
+		});
+
 		const timer = setTimeout(() => {
 			proc.kill("SIGTERM");
-			resolve(0);
+			resolve({ exitCode: 0, stdout: "" });
 		}, timeout);
 
 		proc.on("close", (code) => {
 			clearTimeout(timer);
-			resolve(code ?? 0);
+			resolve({ exitCode: code ?? 0, stdout });
 		});
 
 		proc.on("error", () => {
 			clearTimeout(timer);
-			resolve(0);
+			resolve({ exitCode: 0, stdout: "" });
 		});
 	});
 }
 
+export function parseStdout(stdout: string): HookResult | null {
+	if (!stdout.trim()) {
+		return null;
+	}
+
+	try {
+		return JSON.parse(stdout.trim()) as HookResult;
+	} catch {
+		return null;
+	}
+}
+
 export default function hooksEngine(pi: ExtensionAPI): void {
 	const subscribe = (eventName: string) => {
 		const hookKey = EVENT_MAP[eventName];
 		if (!hookKey) return;
 
-		pi.on(eventName, async (event: Record<string, unknown>) => {
+		pi.on(eventName, async (event: Record<string, unknown>, ctx: any) => {
 			const vars = event.variables as Record<string, string> | undefined;
 			if (!vars?.agentHooks) return undefined;
 
@@ -86,25 +137,62 @@ export default function hooksEngine(pi: ExtensionAPI): void {
 			const eventHooks = hooks[hookKey] ?? hooks["*"] ?? [];
 			if (eventHooks.length === 0) return undefined;
 
-			const results: string[] = [];
+			const promptResults: string[] = [];
 
 			for (const hook of eventHooks) {
 				if (!matchesCondition(hook.if, event)) continue;
 
 				if (hook.type === "command") {
-					const code = await executeCommand(hook.command, event);
-					if (code === 2) {
+					const { exitCode, stdout } = await executeCommand(hook.command, event);
+
+					if (exitCode === 0 && stdout.trim()) {
+						const parsed = parseStdout(stdout);
+						if (parsed?.action === "allow" && parsed.message) {
+							console.log("[hook] Context injection:", parsed.message);
+						} else if (!parsed && stdout.trim()) {
+							console.log("[hook] Message:", stdout.trim());
+						}
+						continue;
+					}
+
+					if (exitCode === 2) {
+						const parsed = parseStdout(stdout);
+						const reason = parsed?.reason ?? stdout.trim() ?? `[hook] Operation blocked by hook: ${hook.command}`;
 						return {
 							block: true,
-							reason: `[hook] Operation blocked by hook: ${hook.command}`,
+							reason,
 						};
 					}
+
+					if (exitCode === 3) {
+						const parsed = parseStdout(stdout);
+						const question = parsed?.question ?? stdout.trim() ?? "Confirm this operation?";
+						
+						if (ctx?.ui?.confirm) {
+							const confirmed = await ctx.ui.confirm(question, "no");
+							if (!confirmed) {
+								return {
+									block: true,
+									reason: "[hook] User denied the operation",
+								};
+							}
+							continue;
+						} else {
+							return {
+								block: true,
+								reason: "[hook] Ask confirmation not supported in this context",
+							};
+						}
+					}
+
+					continue;
 				} else if (hook.type === "prompt") {
-					results.push(hook.prompt);
+					promptResults.push(hook.prompt);
 				}
 			}
 
-			if (results.length > 0) {
+			if (promptResults.length > 0) {
+				console.log("[hook] Prompts to inject:", promptResults);
 			}
 
 			return undefined;

package/dist/extensions/lsp/lsp/index.ts

@@ -11,6 +11,7 @@ import { createDependencyResolver } from "./utils/dependency-resolver.js";
 import { createWriteThroughHooks } from "./hooks/writethrough.js";
 import { createLspToolRouter } from "./tools/lsp-tool.js";
 import { createServerMetricsCollector } from "./monitoring/server-metrics.js";
+import { scanProjectFileTypes, filterServersByProject } from "./utils/project-scanner.js";
 
 export interface LspChannelEvent {
 	event:
@@ -143,14 +144,31 @@ export default function lspExtension(pi: ExtensionAPI): void {
 
 		const config = configResolver.resolve();
 
+		// Scan project for file types and filter servers
+		const cwd = process.cwd();
+		const scanResult = scanProjectFileTypes(cwd);
+		const filteredServers = filterServersByProject(config.servers, scanResult);
+		const skippedNames = config.servers
+			.filter((s) => !filteredServers.some((f) => f.name === s.name))
+			.map((s) => s.name);
+		const discoveredExts = [...scanResult.discoveredExtensions].sort();
+
+		if (skippedNames.length > 0) {
+			console.log(
+				`[lsp] Project scan found [${discoveredExts.join(", ")}], starting ${filteredServers.length}/${config.servers.length} servers (skipped: ${skippedNames.join(", ")})`,
+			);
+		}
+
+		const filteredConfig = { ...config, servers: filteredServers };
+
 		lspChannel?.emit("startup_begin", {
 			event: "startup_begin",
 			timestamp: Date.now(),
-			servers: config.servers.map((s) => ({ name: s.name, state: "starting", fileTypes: s.fileTypes })),
-			totalServers: config.servers.length,
+			servers: filteredConfig.servers.map((s) => ({ name: s.name, state: "starting", fileTypes: s.fileTypes })),
+			totalServers: filteredConfig.servers.length,
 		});
 
-		await runtime.start(config);
+		await runtime.start(filteredConfig);
 		const status = runtime.getStatus();
 
 		for (const srv of status.servers) {

package/dist/extensions/lsp/lsp/utils/project-scanner.ts

@@ -0,0 +1,102 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+import type { ResolvedLspServerConfig } from "../config/resolver.js";
+
+export interface ProjectScanResult {
+	discoveredExtensions: Set<string>;
+}
+
+/**
+ * Scan the project for file types present on disk.
+ * Uses `git ls-files` when available (fast, respects .gitignore),
+ * falls back to a shallow `find` otherwise.
+ */
+export function scanProjectFileTypes(cwd: string): ProjectScanResult {
+	const extensions = new Set<string>();
+
+	// Strategy 1: git ls-files (fast, respects gitignore)
+	const gitFiles = tryGitLsFiles(cwd);
+	if (gitFiles.length > 0) {
+		for (const file of gitFiles) {
+			const ext = extname(file).toLowerCase();
+			if (ext) {
+				extensions.add(ext);
+			}
+		}
+		return { discoveredExtensions: extensions };
+	}
+
+	// Strategy 2: shallow find (maxdepth 3, skip node_modules etc.)
+	try {
+		const output = execSync(
+			'find . -maxdepth 3 -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/target/*" -not -path "*/dist/*" -not -path "*/.pi/*" 2>/dev/null | head -2000',
+			{ cwd, timeout: 3000, encoding: "utf8" },
+		);
+		for (const line of output.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			const ext = extname(trimmed).toLowerCase();
+			if (ext) {
+				extensions.add(ext);
+			}
+		}
+	} catch {
+		// If scan fails, return empty — will fall back to starting all servers
+	}
+
+	return { discoveredExtensions: extensions };
+}
+
+function tryGitLsFiles(cwd: string): string[] {
+	// Check if we're in a git repo
+	if (!existsSync(join(cwd, ".git"))) {
+		return [];
+	}
+
+	try {
+		const output = execSync("git ls-files --cached --others --exclude-standard 2>/dev/null | head -2000", {
+			cwd,
+			timeout: 3000,
+			encoding: "utf8",
+		});
+		const files = output.split("\n").filter(Boolean);
+		return files.length > 0 ? files : [];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Filter server configs to only those whose fileTypes match files in the project.
+ * Servers WITHOUT fileTypes (catch-all) are always included.
+ * If the project has no discoverable files, all servers are started (safe fallback).
+ */
+export function filterServersByProject(
+	servers: ResolvedLspServerConfig[],
+	scanResult: ProjectScanResult,
+): ResolvedLspServerConfig[] {
+	const { discoveredExtensions } = scanResult;
+
+	// Safe fallback: if scan found nothing, start everything
+	if (discoveredExtensions.size === 0) {
+		return servers;
+	}
+
+	const filtered: ResolvedLspServerConfig[] = [];
+	for (const server of servers) {
+		// No fileTypes = catch-all server, always include
+		if (!server.fileTypes || server.fileTypes.length === 0) {
+			filtered.push(server);
+			continue;
+		}
+
+		// Include if ANY of the server's fileTypes exist in the project
+		const hasMatch = server.fileTypes.some((ft) => discoveredExtensions.has(ft.toLowerCase()));
+		if (hasMatch) {
+			filtered.push(server);
+		}
+	}
+
+	return filtered;
+}