@mseep/obsidian-agent-client 0.10.6

package/src/acp/acp-handler.ts

@@ -0,0 +1,252 @@
+import * as acp from "@agentclientprotocol/sdk";
+
+import type { SessionUpdate } from "../types/session";
+import { AcpTypeConverter } from "./type-converter";
+import type { PermissionManager } from "./permission-handler";
+import type { TerminalManager } from "./terminal-handler";
+import type { Logger } from "../utils/logger";
+
+/**
+ * Handles incoming ACP protocol events from the agent.
+ *
+ * Implements the acp.Client interface to receive session updates,
+ * permission requests, and terminal operations from the SDK's
+ * ClientSideConnection dispatch.
+ *
+ * This class does not initiate communication — that is AcpClient's role.
+ * It only reacts to events from the agent side.
+ */
+export class AcpHandler {
+	private sessionUpdateListeners = new Set<(update: SessionUpdate) => void>();
+
+	/** Tracks session updates during a prompt. */
+	private promptSessionUpdateCount = 0;
+
+	constructor(
+		private permissionManager: PermissionManager,
+		private terminalManager: TerminalManager,
+		private getWorkingDirectory: () => string,
+		private getCurrentSessionId: () => string | null,
+		private logger: Logger,
+	) {}
+
+	// ====================================================================
+	// Callback Registration
+	// ====================================================================
+
+	/** Reset the update counter. Called by AcpClient before each sendPrompt. */
+	resetUpdateCount(): void {
+		this.promptSessionUpdateCount = 0;
+	}
+
+	/** Whether any session update was received since the last reset. */
+	hasReceivedUpdates(): boolean {
+		return this.promptSessionUpdateCount > 0;
+	}
+
+	onSessionUpdate(callback: (update: SessionUpdate) => void): () => void {
+		this.sessionUpdateListeners.add(callback);
+		return () => this.sessionUpdateListeners.delete(callback);
+	}
+
+	/** Emit a session update to all listeners. Filters by current sessionId. */
+	emitSessionUpdate(update: SessionUpdate): void {
+		const currentId = this.getCurrentSessionId();
+		if (currentId && update.sessionId !== currentId) {
+			return;
+		}
+		for (const listener of this.sessionUpdateListeners) {
+			listener(update);
+		}
+	}
+
+	// ====================================================================
+	// ACP Client Protocol Handlers (called by ClientSideConnection)
+	// ====================================================================
+
+	sessionUpdate(params: acp.SessionNotification): Promise<void> {
+		const update = params.update;
+		const sessionId = params.sessionId;
+		this.promptSessionUpdateCount++;
+		this.logger.log("[AcpHandler] sessionUpdate:", { sessionId, update });
+
+		switch (update.sessionUpdate) {
+			case "agent_message_chunk":
+			case "agent_thought_chunk":
+			case "user_message_chunk":
+				if (update.content.type === "text") {
+					this.emitSessionUpdate({
+						type: update.sessionUpdate,
+						sessionId,
+						text: update.content.text,
+					});
+				}
+				break;
+
+			case "tool_call":
+			case "tool_call_update":
+				this.emitSessionUpdate({
+					type: update.sessionUpdate,
+					sessionId,
+					toolCallId: update.toolCallId,
+					title: update.title ?? undefined,
+					status: update.status || "pending",
+					kind: update.kind ?? undefined,
+					content: AcpTypeConverter.toToolCallContent(update.content),
+					locations: update.locations ?? undefined,
+					rawInput: update.rawInput as
+						| { [k: string]: unknown }
+						| undefined,
+				});
+				break;
+
+			case "plan":
+				this.emitSessionUpdate({
+					type: "plan",
+					sessionId,
+					entries: update.entries,
+				});
+				break;
+
+			case "available_commands_update":
+				this.emitSessionUpdate({
+					type: "available_commands_update",
+					sessionId,
+					commands: AcpTypeConverter.toSlashCommands(
+						update.availableCommands,
+					),
+				});
+				break;
+
+			case "current_mode_update":
+				this.emitSessionUpdate({
+					type: "current_mode_update",
+					sessionId,
+					currentModeId: update.currentModeId,
+				});
+				break;
+
+			case "session_info_update":
+				this.emitSessionUpdate({
+					type: "session_info_update",
+					sessionId,
+					title: update.title,
+					updatedAt: update.updatedAt,
+				});
+				break;
+
+			case "usage_update":
+				this.emitSessionUpdate({
+					type: "usage_update",
+					sessionId,
+					size: update.size,
+					used: update.used,
+					cost: update.cost ?? undefined,
+				});
+				break;
+
+			case "config_option_update":
+				this.emitSessionUpdate({
+					type: "config_option_update",
+					sessionId,
+					configOptions: AcpTypeConverter.toSessionConfigOptions(
+						update.configOptions,
+					),
+				});
+				break;
+		}
+		return Promise.resolve();
+	}
+
+	requestPermission(
+		params: acp.RequestPermissionRequest,
+	): Promise<acp.RequestPermissionResponse> {
+		return this.permissionManager.request(params);
+	}
+
+	// ====================================================================
+	// ACP Extension Handlers
+	// ====================================================================
+
+	async extNotification(
+		method: string,
+		params: Record<string, unknown>,
+	): Promise<void> {
+		this.logger.log(
+			`[AcpHandler] Extension notification received: ${method}`,
+			params,
+		);
+	}
+
+	// ====================================================================
+	// File System Stubs
+	// ====================================================================
+
+	readTextFile(_params: acp.ReadTextFileRequest) {
+		return Promise.resolve({ content: "" });
+	}
+
+	writeTextFile(_params: acp.WriteTextFileRequest) {
+		return Promise.resolve({});
+	}
+
+	// ====================================================================
+	// Terminal Operations (called by ClientSideConnection)
+	// ====================================================================
+
+	createTerminal(
+		params: acp.CreateTerminalRequest,
+	): Promise<acp.CreateTerminalResponse> {
+		this.logger.log(
+			"[AcpHandler] createTerminal called with params:",
+			params,
+		);
+
+		const terminalId = this.terminalManager.createTerminal({
+			command: params.command,
+			args: params.args,
+			cwd: params.cwd || this.getWorkingDirectory(),
+			env: params.env ?? undefined,
+			outputByteLimit: params.outputByteLimit ?? undefined,
+		});
+		return Promise.resolve({ terminalId });
+	}
+
+	terminalOutput(
+		params: acp.TerminalOutputRequest,
+	): Promise<acp.TerminalOutputResponse> {
+		const result = this.terminalManager.getOutput(params.terminalId);
+		if (!result) {
+			throw new Error(`Terminal ${params.terminalId} not found`);
+		}
+		return Promise.resolve(result);
+	}
+
+	async waitForTerminalExit(
+		params: acp.WaitForTerminalExitRequest,
+	): Promise<acp.WaitForTerminalExitResponse> {
+		return await this.terminalManager.waitForExit(params.terminalId);
+	}
+
+	killTerminal(
+		params: acp.KillTerminalCommandRequest,
+	): Promise<acp.KillTerminalCommandResponse> {
+		const success = this.terminalManager.killTerminal(params.terminalId);
+		if (!success) {
+			throw new Error(`Terminal ${params.terminalId} not found`);
+		}
+		return Promise.resolve({});
+	}
+
+	releaseTerminal(
+		params: acp.ReleaseTerminalRequest,
+	): Promise<acp.ReleaseTerminalResponse> {
+		const success = this.terminalManager.releaseTerminal(params.terminalId);
+		if (!success) {
+			this.logger.log(
+				`[AcpHandler] releaseTerminal: Terminal ${params.terminalId} not found (may have been already cleaned up)`,
+			);
+		}
+		return Promise.resolve({});
+	}
+}

package/src/acp/permission-handler.ts

@@ -0,0 +1,282 @@
+import * as acp from "@agentclientprotocol/sdk";
+import type { PermissionOption } from "../types/chat";
+import type { SessionUpdate } from "../types/session";
+import { AcpTypeConverter } from "./type-converter";
+import { getLogger, Logger } from "../utils/logger";
+
+/**
+ * Callbacks that PermissionManager uses to communicate with the outside world.
+ *
+ * Injected by AcpClient. All UI updates (permission requests, responses,
+ * cancellations) flow through the single onSessionUpdate channel.
+ */
+interface PermissionManagerCallbacks {
+	/** Emit a session update event (used for all permission UI notifications) */
+	onSessionUpdate: (update: SessionUpdate) => void;
+}
+
+/**
+ * Manages permission request lifecycle for ACP agent operations.
+ *
+ * Handles:
+ * - Receiving permission requests from the agent (via ACP protocol)
+ * - Auto-approval based on user settings
+ * - Queuing requests (only one active at a time in UI)
+ * - Resolving/cancelling pending permission Promises
+ * - Notifying UI of permission state changes
+ *
+ * This class was extracted from AcpClient to separate the permission
+ * state machine from the main protocol adapter.
+ */
+export class PermissionManager {
+	private logger: Logger;
+	private callbacks: PermissionManagerCallbacks;
+	private autoAllow: boolean;
+
+	/** Map of pending permission requests awaiting user response */
+	private pendingRequests = new Map<
+		string,
+		{
+			resolve: (response: acp.RequestPermissionResponse) => void;
+			toolCallId: string;
+			options: PermissionOption[];
+			sessionId: string;
+		}
+	>();
+
+	/** Queue of permission requests (first entry is the active one in UI) */
+	private requestQueue: Array<{
+		requestId: string;
+		toolCallId: string;
+		options: PermissionOption[];
+		sessionId: string;
+	}> = [];
+
+	constructor(callbacks: PermissionManagerCallbacks, autoAllow: boolean) {
+		this.logger = getLogger();
+		this.callbacks = callbacks;
+		this.autoAllow = autoAllow;
+	}
+
+	/**
+	 * Update the auto-allow setting.
+	 * Called by AcpClient during initialize() when settings are read.
+	 */
+	setAutoAllow(autoAllow: boolean): void {
+		this.autoAllow = autoAllow;
+	}
+
+	/**
+	 * Handle a permission request from the agent (ACP protocol).
+	 *
+	 * This is the core method called by AcpClient.requestPermission().
+	 * It either auto-approves or creates a pending request with a Promise
+	 * that resolves when the user responds via the UI.
+	 */
+	async request(
+		params: acp.RequestPermissionRequest,
+	): Promise<acp.RequestPermissionResponse> {
+		this.logger.log(
+			"[PermissionManager] Permission request received:",
+			params,
+		);
+
+		// If auto-allow is enabled, automatically approve the first allow option
+		if (this.autoAllow) {
+			const allowOption =
+				params.options.find(
+					(option) =>
+						option.kind === "allow_once" ||
+						option.kind === "allow_always" ||
+						(!option.kind &&
+							option.name.toLowerCase().includes("allow")),
+				) || params.options[0]; // fallback to first option
+
+			this.logger.log(
+				"[PermissionManager] Auto-allowing permission request:",
+				allowOption,
+			);
+
+			return Promise.resolve({
+				outcome: {
+					outcome: "selected",
+					optionId: allowOption.optionId,
+				},
+			});
+		}
+
+		// Generate unique ID for this permission request
+		const requestId = crypto.randomUUID();
+		const toolCallId = params.toolCall?.toolCallId || crypto.randomUUID();
+		const sessionId = params.sessionId;
+
+		const normalizedOptions: PermissionOption[] = params.options.map(
+			(option) => {
+				const normalizedKind =
+					option.kind === "reject_always"
+						? "reject_once"
+						: option.kind;
+				const kind: PermissionOption["kind"] = normalizedKind
+					? normalizedKind
+					: option.name.toLowerCase().includes("allow")
+						? "allow_once"
+						: "reject_once";
+
+				return {
+					optionId: option.optionId,
+					name: option.name,
+					kind,
+				};
+			},
+		);
+
+		const isFirstRequest = this.requestQueue.length === 0;
+
+		// Prepare permission request data
+		const permissionRequestData = {
+			requestId: requestId,
+			options: normalizedOptions,
+			isActive: isFirstRequest,
+		};
+
+		this.requestQueue.push({
+			requestId,
+			toolCallId,
+			options: normalizedOptions,
+			sessionId,
+		});
+
+		// Emit tool_call with permission request via session update callback
+		const toolCallInfo = params.toolCall;
+		this.callbacks.onSessionUpdate({
+			type: "tool_call",
+			sessionId,
+			toolCallId: toolCallId,
+			title: toolCallInfo?.title ?? undefined,
+			status: toolCallInfo?.status || "pending",
+			kind: (toolCallInfo?.kind as acp.ToolKind | undefined) ?? undefined,
+			content: AcpTypeConverter.toToolCallContent(
+				toolCallInfo?.content,
+			),
+			rawInput: toolCallInfo?.rawInput as
+				| { [k: string]: unknown }
+				| undefined,
+			permissionRequest: permissionRequestData,
+		});
+
+		// Return a Promise that will be resolved when user clicks a button
+		return new Promise((resolve) => {
+			this.pendingRequests.set(requestId, {
+				resolve,
+				toolCallId,
+				options: normalizedOptions,
+				sessionId,
+			});
+		});
+	}
+
+	/**
+	 * Handle user's response to a permission request.
+	 *
+	 * Resolves the pending Promise, updates UI, and activates the next
+	 * queued request if any.
+	 */
+	respond(requestId: string, optionId: string): void {
+		const request = this.pendingRequests.get(requestId);
+		if (!request) {
+			return;
+		}
+
+		const { resolve, toolCallId, options, sessionId } = request;
+
+		// Reflect the selection in the UI via session update
+		this.callbacks.onSessionUpdate({
+			type: "tool_call_update",
+			sessionId,
+			toolCallId,
+			permissionRequest: {
+				requestId,
+				options,
+				selectedOptionId: optionId,
+				isActive: false,
+			},
+		});
+
+		resolve({
+			outcome: {
+				outcome: "selected",
+				optionId,
+			},
+		});
+		this.pendingRequests.delete(requestId);
+		this.requestQueue = this.requestQueue.filter(
+			(entry) => entry.requestId !== requestId,
+		);
+		this.activateNext();
+	}
+
+	/**
+	 * Cancel all pending permission requests.
+	 *
+	 * Called during cancel() and disconnect() to clean up.
+	 * Updates UI to show cancelled state and resolves all Promises
+	 * with cancelled outcome.
+	 */
+	cancelAll(): void {
+		this.logger.log(
+			`[PermissionManager] Cancelling ${this.pendingRequests.size} pending permission requests`,
+		);
+		this.pendingRequests.forEach(
+			({ resolve, toolCallId, options, sessionId }, requestId) => {
+				// Update UI to show cancelled state via session update
+				this.callbacks.onSessionUpdate({
+					type: "tool_call_update",
+					sessionId,
+					toolCallId,
+					status: "completed",
+					permissionRequest: {
+						requestId,
+						options,
+						isCancelled: true,
+						isActive: false,
+					},
+				});
+
+				// Resolve the promise with cancelled outcome
+				resolve({
+					outcome: {
+						outcome: "cancelled",
+					},
+				});
+			},
+		);
+		this.pendingRequests.clear();
+		this.requestQueue = [];
+	}
+
+	/**
+	 * Activate the next queued permission request in UI.
+	 */
+	private activateNext(): void {
+		if (this.requestQueue.length === 0) {
+			return;
+		}
+
+		const next = this.requestQueue[0];
+		const pending = this.pendingRequests.get(next.requestId);
+		if (!pending) {
+			return;
+		}
+
+		this.callbacks.onSessionUpdate({
+			type: "tool_call_update",
+			sessionId: next.sessionId,
+			toolCallId: next.toolCallId,
+			permissionRequest: {
+				requestId: next.requestId,
+				options: pending.options,
+				isActive: true,
+			},
+		});
+	}
+}