@mseep/obsidian-agent-client 0.10.6

package/src/acp/terminal-handler.ts

@@ -0,0 +1,264 @@
+import { spawn, ChildProcess, SpawnOptions } from "child_process";
+import type AgentClientPlugin from "../plugin";
+import { getLogger, Logger } from "../utils/logger";
+import { Platform } from "obsidian";
+import { resolveNodeDirectory } from "../utils/paths";
+import { getEnhancedWindowsEnv, prepareShellCommand } from "../utils/platform";
+
+/**
+ * Parameters for creating a terminal process.
+ *
+ * This is the TerminalManager's own parameter type, independent of the ACP SDK.
+ * The AcpClient is responsible for converting ACP protocol types to this format.
+ */
+interface CreateTerminalParams {
+	/** The command to execute */
+	command: string;
+	/** Command arguments */
+	args?: string[];
+	/** Working directory for the command (absolute path) */
+	cwd?: string;
+	/** Environment variables as name-value pairs */
+	env?: Array<{ name: string; value: string }>;
+	/** Maximum number of output bytes to retain */
+	outputByteLimit?: number;
+}
+
+interface TerminalProcess {
+	id: string;
+	process: ChildProcess;
+	output: string;
+	exitStatus: { exitCode: number | null; signal: string | null } | null;
+	outputByteLimit?: number;
+	waitPromises: Array<
+		(exitStatus: { exitCode: number | null; signal: string | null }) => void
+	>;
+	cleanupTimeout?: number;
+}
+
+export class TerminalManager {
+	private terminals = new Map<string, TerminalProcess>();
+	private logger: Logger;
+	private plugin: AgentClientPlugin;
+
+	constructor(plugin: AgentClientPlugin) {
+		this.logger = getLogger();
+		this.plugin = plugin;
+	}
+
+	createTerminal(params: CreateTerminalParams): string {
+		const terminalId = crypto.randomUUID();
+
+		// Check current platform
+		if (!Platform.isDesktopApp) {
+			throw new Error("Agent Client is only available on desktop");
+		}
+
+		// Set up environment variables
+		// Desktop-only: Node.js process environment for terminal operations
+		let env: NodeJS.ProcessEnv = { ...process.env };
+
+		// On Windows (non-WSL mode), enhance PATH with full system/user PATH from registry.
+		// Electron apps launched from shortcuts don't inherit the full PATH.
+		if (Platform.isWin && !this.plugin.settings.windowsWslMode) {
+			env = getEnhancedWindowsEnv(env);
+		}
+
+		if (params.env) {
+			for (const envVar of params.env) {
+				env[envVar.name] = envVar.value;
+			}
+		}
+
+		// Handle command parsing
+		let command = params.command;
+		let args = params.args || [];
+
+		// Platform-specific shell wrapping
+		const nodeDir = resolveNodeDirectory(this.plugin.settings.nodePath);
+		const prepared = prepareShellCommand(
+			command,
+			args,
+			params.cwd || process.cwd(),
+			{
+				wslMode: this.plugin.settings.windowsWslMode,
+				wslDistribution: this.plugin.settings.windowsWslDistribution,
+				nodeDir,
+				alwaysEscape: false,
+			},
+		);
+		command = prepared.command;
+		args = prepared.args;
+		const needsShell = prepared.needsShell;
+
+		this.logger.log(`[Terminal ${terminalId}] Creating terminal:`, {
+			command,
+			args,
+			cwd: params.cwd,
+		});
+
+		// Spawn the process
+		const spawnOptions: SpawnOptions = {
+			cwd: params.cwd || undefined,
+			env,
+			stdio: ["pipe", "pipe", "pipe"],
+			shell: needsShell,
+		};
+		const childProcess = spawn(command, args, spawnOptions);
+
+		const terminal: TerminalProcess = {
+			id: terminalId,
+			process: childProcess,
+			output: "",
+			exitStatus: null,
+			outputByteLimit:
+				params.outputByteLimit !== undefined
+					? Number(params.outputByteLimit)
+					: undefined,
+			waitPromises: [],
+		};
+
+		// Handle spawn errors
+		childProcess.on("error", (error) => {
+			this.logger.log(
+				`[Terminal ${terminalId}] Process error:`,
+				error.message,
+			);
+			// Set exit status to indicate failure
+			const exitStatus = { exitCode: 127, signal: null }; // 127 = command not found
+			terminal.exitStatus = exitStatus;
+			// Resolve all waiting promises
+			terminal.waitPromises.forEach((resolve) => resolve(exitStatus));
+			terminal.waitPromises = [];
+		});
+
+		// Capture stdout and stderr
+		childProcess.stdout?.on("data", (data: Buffer) => {
+			const output = data.toString();
+			this.logger.log(`[Terminal ${terminalId}] stdout:`, output);
+			this.appendOutput(terminal, output);
+		});
+
+		childProcess.stderr?.on("data", (data: Buffer) => {
+			const output = data.toString();
+			this.logger.log(`[Terminal ${terminalId}] stderr:`, output);
+			this.appendOutput(terminal, output);
+		});
+
+		// Handle process exit
+		childProcess.on("exit", (code, signal) => {
+			this.logger.log(
+				`[Terminal ${terminalId}] Process exited with code: ${code}, signal: ${signal}`,
+			);
+			const exitStatus = { exitCode: code, signal };
+			terminal.exitStatus = exitStatus;
+			// Resolve all waiting promises
+			terminal.waitPromises.forEach((resolve) => resolve(exitStatus));
+			terminal.waitPromises = [];
+		});
+
+		this.terminals.set(terminalId, terminal);
+		return terminalId;
+	}
+
+	private appendOutput(terminal: TerminalProcess, data: string): void {
+		terminal.output += data;
+
+		// Apply output byte limit if specified
+		if (
+			terminal.outputByteLimit &&
+			Buffer.byteLength(terminal.output, "utf8") >
+				terminal.outputByteLimit
+		) {
+			// Truncate from the beginning, ensuring we stay at character boundaries
+			const bytes = Buffer.from(terminal.output, "utf8");
+			const truncatedBytes = bytes.subarray(
+				bytes.length - terminal.outputByteLimit,
+			);
+			terminal.output = truncatedBytes.toString("utf8");
+		}
+	}
+
+	getOutput(terminalId: string): {
+		output: string;
+		truncated: boolean;
+		exitStatus: { exitCode: number | null; signal: string | null } | null;
+	} | null {
+		const terminal = this.terminals.get(terminalId);
+		if (!terminal) return null;
+
+		return {
+			output: terminal.output,
+			truncated: terminal.outputByteLimit
+				? Buffer.byteLength(terminal.output, "utf8") >=
+					terminal.outputByteLimit
+				: false,
+			exitStatus: terminal.exitStatus,
+		};
+	}
+
+	waitForExit(
+		terminalId: string,
+	): Promise<{ exitCode: number | null; signal: string | null }> {
+		const terminal = this.terminals.get(terminalId);
+		if (!terminal) {
+			return Promise.reject(
+				new Error(`Terminal ${terminalId} not found`),
+			);
+		}
+
+		if (terminal.exitStatus) {
+			return Promise.resolve(terminal.exitStatus);
+		}
+
+		return new Promise((resolve) => {
+			terminal.waitPromises.push(resolve);
+		});
+	}
+
+	killTerminal(terminalId: string): boolean {
+		const terminal = this.terminals.get(terminalId);
+		if (!terminal) return false;
+
+		if (!terminal.exitStatus) {
+			terminal.process.kill("SIGTERM");
+		}
+		return true;
+	}
+
+	releaseTerminal(terminalId: string): boolean {
+		const terminal = this.terminals.get(terminalId);
+		if (!terminal) return false;
+
+		this.logger.log(`[Terminal ${terminalId}] Releasing terminal`);
+		if (!terminal.exitStatus) {
+			terminal.process.kill("SIGTERM");
+		}
+
+		// Schedule cleanup after 30 seconds to allow UI to poll final output
+		terminal.cleanupTimeout = window.setTimeout(() => {
+			this.logger.log(
+				`[Terminal ${terminalId}] Cleaning up terminal after grace period`,
+			);
+			this.terminals.delete(terminalId);
+		}, 30000);
+
+		return true;
+	}
+
+	killAllTerminals(): void {
+		this.logger.log(`Killing ${this.terminals.size} running terminals...`);
+		this.terminals.forEach((terminal, terminalId) => {
+			// Clear cleanup timeout if scheduled
+			if (terminal.cleanupTimeout) {
+				window.clearTimeout(terminal.cleanupTimeout);
+			}
+			if (!terminal.exitStatus) {
+				this.logger.log(`Killing terminal ${terminalId}`);
+				this.killTerminal(terminalId);
+			}
+		});
+		// Clear all terminals
+		this.terminals.clear();
+	}
+}

package/src/acp/type-converter.ts

@@ -0,0 +1,272 @@
+import * as acp from "@agentclientprotocol/sdk";
+import type { ToolCallContent, PromptContent } from "../types/chat";
+import type {
+	InitializeResult,
+	SessionConfigOption,
+	SessionConfigSelectGroup,
+	SessionConfigSelectOption,
+	SessionResult,
+	SlashCommand,
+} from "../types/session";
+
+/**
+ * Common shape of ACP session responses.
+ *
+ * NewSessionResponse and ForkSessionResponse include sessionId.
+ * LoadSessionResponse and ResumeSessionResponse do not (the sessionId
+ * is the same as the request parameter). This interface captures the
+ * shared fields for type-safe conversion; sessionId is optional here
+ * and supplied explicitly when missing from the response.
+ */
+interface AcpSessionResponse {
+	sessionId?: string;
+	modes?: acp.SessionModeState | null;
+	models?: acp.SessionModelState | null;
+	configOptions?: acp.SessionConfigOption[] | null;
+}
+
+/**
+ * Type converter between ACP Protocol types and Domain types.
+ *
+ * This adapter ensures the domain layer remains independent of the ACP library.
+ * When the ACP protocol changes, only this converter needs to be updated.
+ */
+export class AcpTypeConverter {
+	/**
+	 * Convert ACP ToolCallContent to domain ToolCallContent.
+	 *
+	 * Filters out content types that are not supported by the domain model:
+	 * - Supports: "diff", "terminal"
+	 * - Ignores: "content" (not implemented in UI)
+	 *
+	 * @param acpContent - Tool call content from ACP protocol
+	 * @returns Domain model tool call content, or undefined if input is null/empty
+	 */
+	/**
+	 * Convert ACP AvailableCommand[] to domain SlashCommand[].
+	 */
+	static toSlashCommands(
+		acpCommands: acp.AvailableCommand[] | undefined | null,
+	): SlashCommand[] {
+		return (acpCommands || []).map((cmd) => ({
+			name: cmd.name,
+			description: cmd.description,
+			hint: cmd.input?.hint ?? null,
+		}));
+	}
+
+	static toToolCallContent(
+		acpContent: acp.ToolCallContent[] | undefined | null,
+	): ToolCallContent[] | undefined {
+		if (!acpContent) return undefined;
+
+		const converted: ToolCallContent[] = [];
+
+		for (const item of acpContent) {
+			if (item.type === "diff") {
+				converted.push({
+					type: "diff",
+					path: item.path,
+					newText: item.newText,
+					oldText: item.oldText,
+				});
+			} else if (item.type === "terminal") {
+				converted.push({
+					type: "terminal",
+					terminalId: item.terminalId,
+				});
+			}
+			// "content" type is intentionally ignored (not implemented in UI)
+		}
+
+		return converted.length > 0 ? converted : undefined;
+	}
+
+	/**
+	 * Convert domain PromptContent to ACP ContentBlock.
+	 *
+	 * This converts our domain-layer prompt content to the ACP protocol format
+	 * for sending to the agent.
+	 *
+	 * @param content - Domain prompt content (text, image, resource, or resource_link)
+	 * @returns ACP ContentBlock for use with the prompt API
+	 */
+	/**
+	 * Convert ACP SessionConfigOption[] to domain SessionConfigOption[].
+	 *
+	 * @param acpOptions - Config options from ACP protocol
+	 * @returns Domain model config options
+	 */
+	static toSessionConfigOptions(
+		acpOptions: acp.SessionConfigOption[],
+	): SessionConfigOption[] {
+		return acpOptions.map((opt) => ({
+			id: opt.id,
+			name: opt.name,
+			description: opt.description ?? undefined,
+			category: opt.category ?? undefined,
+			type: opt.type,
+			currentValue: opt.currentValue,
+			options: this.toSessionConfigSelectOptions(opt.options),
+		}));
+	}
+
+	private static toSessionConfigSelectOptions(
+		acpOptions: acp.SessionConfigSelectOptions,
+	): SessionConfigSelectOption[] | SessionConfigSelectGroup[] {
+		if (acpOptions.length === 0) return [];
+
+		// Determine if grouped or flat by checking first element
+		const first = acpOptions[0];
+		if ("group" in first) {
+			return (acpOptions as acp.SessionConfigSelectGroup[]).map((g) => ({
+				group: g.group,
+				name: g.name,
+				options: g.options.map((o) => ({
+					value: o.value,
+					name: o.name,
+					description: o.description ?? undefined,
+				})),
+			}));
+		}
+
+		return (acpOptions as acp.SessionConfigSelectOption[]).map((o) => ({
+			value: o.value,
+			name: o.name,
+			description: o.description ?? undefined,
+		}));
+	}
+
+	/**
+	 * Convert ACP session response to domain SessionResult.
+	 *
+	 * Handles the modes/models/configOptions conversion that is common
+	 * to newSession, loadSession, resumeSession, and forkSession responses.
+	 *
+	 * ACP uses `null` for absent optional fields, while domain uses `undefined`.
+	 * This method normalizes that difference.
+	 *
+	 * @param sessionId - The session ID (from response or from request params)
+	 * @param response - ACP session response (new/load/resume/fork)
+	 * @returns Domain SessionResult
+	 */
+	static toSessionResult(
+		sessionId: string,
+		response: AcpSessionResponse,
+	): SessionResult {
+		let modes: SessionResult["modes"];
+		if (response.modes) {
+			modes = {
+				availableModes: response.modes.availableModes.map((m) => ({
+					id: m.id,
+					name: m.name,
+					description: m.description ?? undefined,
+				})),
+				currentModeId: response.modes.currentModeId,
+			};
+		}
+
+		let models: SessionResult["models"];
+		if (response.models) {
+			models = {
+				availableModels: response.models.availableModels.map((m) => ({
+					modelId: m.modelId,
+					name: m.name,
+					description: m.description ?? undefined,
+				})),
+				currentModelId: response.models.currentModelId,
+			};
+		}
+
+		const configOptions = response.configOptions
+			? this.toSessionConfigOptions(response.configOptions)
+			: undefined;
+
+		return {
+			sessionId,
+			modes,
+			models,
+			configOptions,
+		};
+	}
+
+	static toAcpContentBlock(content: PromptContent): acp.ContentBlock {
+		switch (content.type) {
+			case "text":
+				return { type: "text", text: content.text };
+			case "image":
+				return {
+					type: "image",
+					data: content.data,
+					mimeType: content.mimeType,
+				};
+			case "resource":
+				return {
+					type: "resource",
+					resource: {
+						uri: content.resource.uri,
+						mimeType: content.resource.mimeType,
+						text: content.resource.text,
+					},
+					annotations: content.annotations,
+				};
+			case "resource_link":
+				return {
+					type: "resource_link",
+					uri: content.uri,
+					name: content.name,
+					mimeType: content.mimeType,
+					size: content.size,
+				};
+		}
+	}
+
+	/**
+	 * Convert ACP InitializeResponse to domain InitializeResult.
+	 */
+	static toInitializeResult(
+		initResult: acp.InitializeResponse,
+	): InitializeResult {
+		const promptCaps = initResult.agentCapabilities?.promptCapabilities;
+		const mcpCaps = initResult.agentCapabilities?.mcpCapabilities;
+		const sessionCaps = initResult.agentCapabilities?.sessionCapabilities;
+
+		return {
+			protocolVersion: initResult.protocolVersion,
+			authMethods: initResult.authMethods || [],
+			promptCapabilities: {
+				image: promptCaps?.image ?? false,
+				audio: promptCaps?.audio ?? false,
+				embeddedContext: promptCaps?.embeddedContext ?? false,
+			},
+			agentCapabilities: {
+				loadSession: initResult.agentCapabilities?.loadSession ?? false,
+				sessionCapabilities: sessionCaps
+					? {
+							resume: sessionCaps.resume ?? undefined,
+							fork: sessionCaps.fork ?? undefined,
+							list: sessionCaps.list ?? undefined,
+						}
+					: undefined,
+				mcpCapabilities: mcpCaps
+					? {
+							http: mcpCaps.http ?? false,
+							sse: mcpCaps.sse ?? false,
+						}
+					: undefined,
+				promptCapabilities: {
+					image: promptCaps?.image ?? false,
+					audio: promptCaps?.audio ?? false,
+					embeddedContext: promptCaps?.embeddedContext ?? false,
+				},
+			},
+			agentInfo: initResult.agentInfo
+				? {
+						name: initResult.agentInfo.name,
+						title: initResult.agentInfo.title ?? undefined,
+						version: initResult.agentInfo.version ?? undefined,
+					}
+				: undefined,
+		};
+	}
+}