@mako10k/shell-server 0.1.0

package/dist/tools/shell-tools.js

@@ -0,0 +1,861 @@
+import { ShellExecuteParamsSchema, ShellGetExecutionParamsSchema, ShellSetDefaultWorkdirParamsSchema, FileListParamsSchema, FileReadParamsSchema, FileDeleteParamsSchema, TerminalListParamsSchema, TerminalGetParamsSchema, TerminalCloseParamsSchema, CleanupSuggestionsParamsSchema, AutoCleanupParamsSchema, CommandHistoryQueryParamsSchema, } from '../types/schemas.js';
+import { TerminalOperateParamsSchema } from '../types/quick-schemas.js';
+import { RemoteProcessService } from '../core/remote-process-service.js';
+import { MCPShellError } from '../utils/errors.js';
+import { saveCriteria as _saveCriteria, getCriteriaStatus as _getCriteriaStatus } from '../utils/criteria-manager.js'; // Disabled MCP tool functions
+// ...existing code...
+export class ShellTools {
+    processManager;
+    terminalManager;
+    fileManager;
+    monitoringManager;
+    securityManager;
+    historyManager;
+    constructor(processManager, terminalManager, fileManager, monitoringManager, securityManager, historyManager) {
+        this.processManager = processManager;
+        this.terminalManager = terminalManager;
+        this.fileManager = fileManager;
+        this.monitoringManager = monitoringManager;
+        this.securityManager = securityManager;
+        this.historyManager = historyManager;
+    }
+    // Simple backend switch: local (default) or remote
+    isRemoteBackend() {
+        return (process.env['EXECUTION_BACKEND'] || '').toLowerCase() === 'remote';
+    }
+    // Shell Operations
+    async executeShellValidated(rawParams) {
+        const params = ShellExecuteParamsSchema.parse(rawParams);
+        return this.executeShell(params);
+    }
+    async getExecutionValidated(rawParams) {
+        const params = ShellGetExecutionParamsSchema.parse(rawParams);
+        return this.getExecution(params);
+    }
+    async executeShell(params) {
+        try {
+            // Enhanced security evaluation (if enabled)
+            const workingDir = params.working_directory || this.processManager.getDefaultWorkingDirectory();
+            let safetyEvaluation = null;
+            if (this.securityManager.isEnhancedModeEnabled()) {
+                // Evaluate command safety with enhanced evaluator
+                safetyEvaluation = await this.securityManager.evaluateCommandSafetyByEnhancedEvaluator(params.command, workingDir, params.comment, params.force_user_confirm);
+                // Handle evaluation results with strict safety guards
+                if (safetyEvaluation?.getEvaluationResult() === 'deny') {
+                    const toolResponse = safetyEvaluation.generateToolResponse();
+                    throw new Error(`Command denied: ${toolResponse.reasoning}`);
+                }
+                // For NEED_ASSISTANT_CONFIRM, return evaluation info without executing
+                // Assistant must provide additional context
+                if (safetyEvaluation?.getEvaluationResult() === 'ai_assistant_confirm') {
+                    return {
+                        status: 'need_assistant_confirm',
+                        command: params.command,
+                        working_directory: workingDir,
+                        safety_evaluation: safetyEvaluation.generateToolResponse(),
+                        message: 'Command requires assistant confirmation before execution. Assistant should provide more context.',
+                    };
+                }
+                // CRITICAL SAFETY GUARD: Only execute if explicitly ALLOWED
+                if (safetyEvaluation && safetyEvaluation.getEvaluationResult() !== 'allow') {
+                    const toolResponse = safetyEvaluation.generateToolResponse();
+                    throw new Error(`Command execution blocked: evaluation result '${safetyEvaluation.getEvaluationResult()}' is not ALLOW. Reasoning: ${toolResponse.reasoning}`);
+                }
+            }
+            // Traditional security checks (still performed)
+            this.securityManager.auditCommand(params.command, params.working_directory);
+            this.securityManager.validateExecutionTime(params.timeout_seconds);
+            // foreground_timeout_secondsの最大値チェック
+            if (params.execution_mode === 'foreground' &&
+                typeof params.foreground_timeout_seconds === 'number' &&
+                params.foreground_timeout_seconds > 300) {
+                throw new MCPShellError('TIMEOUT_LIMIT_EXCEEDED', `foreground_timeout_seconds (${params.foreground_timeout_seconds}) exceeds the maximum allowed (300 seconds). For timeouts above 300 seconds, use execution_mode 'background' or 'adaptive'.`, 'PARAM');
+            }
+            const executionOptions = {
+                command: params.command,
+                executionMode: params.execution_mode,
+                timeoutSeconds: params.timeout_seconds,
+                foregroundTimeoutSeconds: params.foreground_timeout_seconds,
+                maxOutputSize: params.max_output_size,
+                captureStderr: params.capture_stderr,
+                returnPartialOnTimeout: params.return_partial_on_timeout,
+            };
+            // オプショナルなプロパティを追加（undefinedでない場合のみ）
+            if (params.working_directory !== undefined) {
+                executionOptions.workingDirectory = params.working_directory;
+            }
+            if (params.environment_variables !== undefined) {
+                executionOptions.environmentVariables = params.environment_variables;
+            }
+            if (params.input_data !== undefined) {
+                executionOptions.inputData = params.input_data;
+            }
+            if (params.input_output_id !== undefined) {
+                executionOptions.inputOutputId = params.input_output_id;
+            }
+            if (params.session_id !== undefined) {
+                executionOptions.sessionId = params.session_id;
+            }
+            if (params.create_terminal !== undefined) {
+                executionOptions.createTerminal = params.create_terminal;
+            }
+            if (params.terminal_shell !== undefined) {
+                executionOptions.terminalShell = params.terminal_shell;
+            }
+            if (params.terminal_dimensions !== undefined) {
+                executionOptions.terminalDimensions = params.terminal_dimensions;
+            }
+            let executionInfo;
+            if (this.isRemoteBackend()) {
+                // Minimal remote start: map subset of fields
+                const remote = new RemoteProcessService();
+                const req = {
+                    command: executionOptions.command,
+                    timeout_seconds: executionOptions.timeoutSeconds,
+                    capture_stderr: executionOptions.captureStderr,
+                    max_output_size: executionOptions.maxOutputSize,
+                };
+                if (executionOptions.workingDirectory !== undefined) {
+                    req.working_directory = executionOptions.workingDirectory;
+                }
+                if (safetyEvaluation) {
+                    req.safety_evaluation = safetyEvaluation.generateToolResponse();
+                }
+                const startRes = await remote.start(req);
+                executionInfo = {
+                    execution_id: startRes.execution_id,
+                    command: executionOptions.command,
+                    status: startRes.status,
+                    working_directory: executionOptions.workingDirectory || this.processManager.getDefaultWorkingDirectory(),
+                    created_at: new Date().toISOString(),
+                    started_at: new Date().toISOString(),
+                };
+            }
+            else {
+                executionInfo = await this.processManager.executeCommand(executionOptions);
+            }
+            // Add command to history
+            try {
+                const safetyClassification = this.securityManager.analyzeCommandSafety(params.command);
+                const baseWorkingDir = params.working_directory || this.processManager.getDefaultWorkingDirectory();
+                const outputSize = (executionInfo.stdout?.length || 0) + (executionInfo.stderr?.length || 0);
+                const durationMs = executionInfo.execution_time_ms ?? 0;
+                const exitCode = executionInfo.exit_code ?? 0;
+                await this.historyManager.addHistoryEntry({
+                    command: params.command,
+                    working_directory: baseWorkingDir,
+                    was_executed: true,
+                    resubmission_count: 0,
+                    safety_classification: safetyClassification.classification,
+                    execution_status: executionInfo.status,
+                    output_summary: `Exit code: ${exitCode}, Duration: ${durationMs}ms, Output size: ${outputSize} bytes`,
+                });
+            }
+            catch (historyError) {
+                console.warn('Failed to add command to history:', historyError);
+            }
+            // Include safety evaluation in response if available
+            const response = { ...executionInfo };
+            if (safetyEvaluation) {
+                response['safety_evaluation'] = safetyEvaluation.generateToolResponse();
+            }
+            return response;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async getExecution(params) {
+        try {
+            if (this.isRemoteBackend()) {
+                const remote = new RemoteProcessService();
+                return await remote.get(params.execution_id);
+            }
+            else {
+                const executionInfo = this.processManager.getExecution(params.execution_id);
+                if (!executionInfo) {
+                    throw new MCPShellError('RESOURCE_001', `Execution with ID ${params.execution_id} not found`, 'RESOURCE');
+                }
+                return executionInfo;
+            }
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // Process Management
+    async listProcesses(params) {
+        try {
+            // Convert status filter - handle different enum values
+            let statusFilter = params.status_filter;
+            if (statusFilter === 'all') {
+                statusFilter = undefined;
+            }
+            const listOptions = {
+                limit: params.limit,
+                offset: params.offset,
+            };
+            if (statusFilter !== undefined) {
+                listOptions['status'] = statusFilter;
+            }
+            if (params.command_pattern !== undefined) {
+                listOptions['commandPattern'] = params.command_pattern;
+            }
+            if (params.session_id !== undefined) {
+                listOptions['sessionId'] = params.session_id;
+            }
+            const result = this.processManager.listExecutions(listOptions);
+            return {
+                processes: result.executions,
+                total_count: result.total,
+                filtered_count: result.executions.length,
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async killProcess(params) {
+        try {
+            const result = await this.processManager.killProcess(params.process_id, params.signal, params.force);
+            return {
+                success: result.success,
+                process_id: params.process_id,
+                signal_sent: result.signal_sent,
+                exit_code: result.exit_code,
+                message: result.message,
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async monitorProcess(params) {
+        try {
+            const monitorInfo = this.monitoringManager.startProcessMonitor(params.process_id, params.monitor_interval_ms, params.include_metrics);
+            return monitorInfo;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // File Operations
+    async listFilesValidated(rawParams) {
+        const params = FileListParamsSchema.parse(rawParams ?? {});
+        return this.listFiles(params);
+    }
+    async readFileValidated(rawParams) {
+        const params = FileReadParamsSchema.parse(rawParams);
+        return this.readFile(params);
+    }
+    async deleteFilesValidated(rawParams) {
+        const params = FileDeleteParamsSchema.parse(rawParams);
+        return this.deleteFiles(params);
+    }
+    async listFiles(params) {
+        try {
+            const listOptions = {
+                limit: params.limit,
+            };
+            if (params.output_type !== undefined) {
+                listOptions['outputType'] = params.output_type;
+            }
+            if (params.execution_id !== undefined) {
+                listOptions['executionId'] = params.execution_id;
+            }
+            if (params.name_pattern !== undefined) {
+                listOptions['namePattern'] = params.name_pattern;
+            }
+            const result = this.fileManager.listFiles(listOptions);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async readFile(params) {
+        try {
+            const result = await this.fileManager.readFile(params.output_id, params.offset, params.size, params.encoding);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async deleteFiles(params) {
+        try {
+            const result = await this.fileManager.deleteFiles(params.output_ids, params.confirm);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // Terminal Management
+    async terminalOperateValidated(rawParams) {
+        const params = TerminalOperateParamsSchema.parse(rawParams ?? {});
+        return this.terminalOperate(params);
+    }
+    async listTerminalsValidated(rawParams) {
+        const params = TerminalListParamsSchema.parse(rawParams ?? {});
+        return this.listTerminals(params);
+    }
+    async getTerminalValidated(rawParams) {
+        const params = TerminalGetParamsSchema.parse(rawParams);
+        return this.getTerminal(params);
+    }
+    async closeTerminalValidated(rawParams) {
+        const params = TerminalCloseParamsSchema.parse(rawParams);
+        return this.closeTerminal(params);
+    }
+    // ...existing code...
+    async createTerminal(params) {
+        try {
+            const terminalOptions = {
+                shellType: params.shell_type,
+                dimensions: params.dimensions,
+                autoSaveHistory: params.auto_save_history ?? false,
+                sessionName: params.session_name ?? '',
+                workingDirectory: params.working_directory,
+                environmentVariables: params.environment_variables,
+            };
+            const terminalInfo = await this.terminalManager.createTerminal(terminalOptions);
+            return terminalInfo;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async listTerminals(params) {
+        try {
+            const listOptions = {};
+            if (params.limit !== undefined) {
+                listOptions.limit = params.limit;
+            }
+            if (params.session_name_pattern !== undefined) {
+                listOptions.sessionNamePattern = params.session_name_pattern;
+            }
+            if (params.status_filter !== undefined) {
+                listOptions.statusFilter = params.status_filter;
+            }
+            const result = this.terminalManager.listTerminals(listOptions);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async getTerminal(params) {
+        try {
+            const terminalInfo = await this.terminalManager.getTerminal(params.terminal_id);
+            return terminalInfo;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async sendTerminalInput(params) {
+        try {
+            const result = await this.terminalManager.sendInput(params.terminal_id, params.input, params.execute, params.control_codes, params.raw_bytes, params.send_to);
+            return {
+                success: result.success,
+                input_sent: params.input,
+                control_codes_enabled: params.control_codes || false,
+                raw_bytes_mode: params.raw_bytes || false,
+                program_guard: result.guard_check,
+                timestamp: result.timestamp,
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async getTerminalOutput(params) {
+        try {
+            const result = await this.terminalManager.getOutput(params.terminal_id, params.start_line, params.line_count, params.include_ansi, params.include_foreground_process);
+            const response = {
+                terminal_id: params.terminal_id,
+                output: result.output,
+                line_count: result.line_count,
+                total_lines: result.total_lines,
+                has_more: result.has_more,
+                start_line: result.start_line,
+                next_start_line: result.next_start_line,
+            };
+            if (params.include_foreground_process) {
+                response.foreground_process = result.foreground_process;
+            }
+            return response;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async resizeTerminal(params) {
+        try {
+            const result = this.terminalManager.resizeTerminal(params.terminal_id, params.dimensions);
+            return {
+                success: result.success,
+                terminal_id: params.terminal_id,
+                dimensions: params.dimensions,
+                updated_at: result.updated_at,
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async closeTerminal(params) {
+        try {
+            const result = this.terminalManager.closeTerminal(params.terminal_id, params.save_history);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // Security & Monitoring
+    async setSecurityRestrictions(params) {
+        try {
+            const restrictionParams = {
+                enable_network: params.enable_network,
+            };
+            if (params.allowed_commands !== undefined) {
+                restrictionParams['allowed_commands'] = params.allowed_commands;
+            }
+            if (params.blocked_commands !== undefined) {
+                restrictionParams['blocked_commands'] = params.blocked_commands;
+            }
+            if (params.allowed_directories !== undefined) {
+                restrictionParams['allowed_directories'] = params.allowed_directories;
+            }
+            if (params.max_execution_time !== undefined) {
+                restrictionParams['max_execution_time'] = params.max_execution_time;
+            }
+            if (params.max_memory_mb !== undefined) {
+                restrictionParams['max_memory_mb'] = params.max_memory_mb;
+            }
+            const restrictions = this.securityManager.setRestrictions(restrictionParams);
+            return {
+                restriction_id: restrictions.restriction_id,
+                active: restrictions.active,
+                configured_at: restrictions.configured_at,
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async getMonitoringStats(params) {
+        try {
+            let stats = this.monitoringManager.getSystemStats(params.time_range_minutes);
+            // 要求されたメトリクスのみを含める
+            if (params.include_metrics) {
+                const filteredStats = {
+                    collected_at: stats.collected_at,
+                };
+                for (const metric of params.include_metrics) {
+                    switch (metric) {
+                        case 'processes':
+                            filteredStats['active_processes'] = stats.active_processes;
+                            break;
+                        case 'terminals':
+                            filteredStats['active_terminals'] = stats.active_terminals;
+                            break;
+                        case 'files':
+                            filteredStats['total_files'] = stats.total_files;
+                            break;
+                        case 'system':
+                            filteredStats['system_load'] = stats.system_load;
+                            filteredStats['memory_usage'] = stats.memory_usage;
+                            filteredStats['uptime_seconds'] = stats.uptime_seconds;
+                            break;
+                    }
+                }
+                return filteredStats;
+            }
+            return stats;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async setDefaultWorkingDirectoryValidated(rawParams) {
+        const params = ShellSetDefaultWorkdirParamsSchema.parse(rawParams);
+        return this.setDefaultWorkingDirectory(params);
+    }
+    async setDefaultWorkingDirectory(params) {
+        try {
+            const result = this.processManager.setDefaultWorkingDirectory(params.working_directory);
+            return {
+                success: result.success,
+                previous_working_directory: result.previous_working_directory,
+                new_working_directory: result.new_working_directory,
+                working_directory_changed: result.working_directory_changed,
+                default_working_directory: this.processManager.getDefaultWorkingDirectory(),
+                allowed_working_directories: this.processManager.getAllowedWorkingDirectories(),
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // Issue #15: クリーンアップ提案機能
+    async getCleanupSuggestions(params) {
+        try {
+            const options = {};
+            if (params?.max_size_mb !== undefined)
+                options.maxSizeMB = params.max_size_mb;
+            if (params?.max_age_hours !== undefined)
+                options.maxAgeHours = params.max_age_hours;
+            if (params?.include_warnings !== undefined)
+                options.includeWarnings = params.include_warnings;
+            const result = await this.fileManager.getCleanupSuggestions(options);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // Issue #15: 自動クリーンアップ実行機能
+    async performAutoCleanup(params) {
+        try {
+            const options = {};
+            if (params?.max_age_hours !== undefined)
+                options.maxAgeHours = params.max_age_hours;
+            if (params?.dry_run !== undefined)
+                options.dryRun = params.dry_run;
+            if (params?.preserve_recent !== undefined)
+                options.preserveRecent = params.preserve_recent;
+            const result = await this.fileManager.performAutoCleanup(options);
+            return result;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // 統合ターミナル操作 (create + send_input + get_output を統合)
+    async terminalOperate(params) {
+        try {
+            let terminalId = params.terminal_id;
+            let terminalInfo = null;
+            let inputRejected = false;
+            let rejectionReason = '';
+            let unreadOutput = null;
+            // 1. ターミナルの準備 (新規作成 or 既存利用)
+            if (!terminalId) {
+                if (!params.command) {
+                    throw new Error('Either terminal_id or command must be provided');
+                }
+                // 新規ターミナル作成
+                const createOptions = {
+                    shellType: params.shell_type || 'bash',
+                    dimensions: params.dimensions || { width: 120, height: 30 },
+                    autoSaveHistory: true,
+                    sessionName: params.session_name ?? undefined,
+                    workingDirectory: params.working_directory ?? undefined,
+                    environmentVariables: params.environment_variables ?? undefined,
+                };
+                terminalInfo = await this.terminalManager.createTerminal(createOptions);
+                terminalId = terminalInfo.terminal_id;
+                // 作成後にコマンドを自動実行
+                if (params.command) {
+                    await this.terminalManager.sendInput(terminalId, params.command, true, // execute
+                    params.control_codes || false, false, // raw_bytes
+                    params.send_to // program guard
+                    );
+                }
+            }
+            else {
+                // 既存ターミナル使用
+                terminalInfo = await this.terminalManager.getTerminal(terminalId);
+                // dimensionsが指定されている場合、現在のサイズと比較してリサイズ
+                if (params.dimensions) {
+                    const currentDimensions = terminalInfo.dimensions;
+                    const newDimensions = params.dimensions;
+                    if (currentDimensions.width !== newDimensions.width ||
+                        currentDimensions.height !== newDimensions.height) {
+                        // サイズが異なる場合はリサイズ実行
+                        await this.terminalManager.resizeTerminal(terminalId, newDimensions);
+                        // 最新のターミナル情報を再取得
+                        terminalInfo = await this.terminalManager.getTerminal(terminalId);
+                    }
+                }
+                // inputまたはcommandが指定されていれば送信（未読出力チェック付き）
+                const inputToSend = params.input || params.command;
+                if (typeof inputToSend === 'string' && inputToSend.length > 0) {
+                    // 制御コード送信時は自動的にforce_inputをtrueにする（Ctrl+C等の緊急操作のため）
+                    const effectiveForceInput = params.force_input || params.control_codes;
+                    // 未読出力チェック（force_inputまたはcontrol_codesがfalseの場合のみ）
+                    if (!effectiveForceInput) {
+                        const unreadCheck = await this.terminalManager.getOutput(terminalId, undefined, // start_lineはデフォルト（連続読み取り）
+                        1000, // 大きめの値で未読データを全取得
+                        params.include_ansi || false, false // include_foreground_process
+                        );
+                        if (unreadCheck.output && unreadCheck.output.trim().length > 0) {
+                            inputRejected = true;
+                            rejectionReason =
+                                'Unread output exists. Read output first or use force_input=true to override.';
+                            unreadOutput = unreadCheck;
+                        }
+                    }
+                    // 制約に引っかからなかった場合のみ入力送信
+                    if (!inputRejected) {
+                        await this.terminalManager.sendInput(terminalId, inputToSend, params.execute !== false, // デフォルトtrue
+                        params.control_codes || false, false, // raw_bytes
+                        params.send_to // program guard
+                        );
+                    }
+                }
+            }
+            // 2. 遅延処理（コマンド完了待ち）
+            if (params.output_delay_ms > 0) {
+                await new Promise((resolve) => setTimeout(resolve, params.output_delay_ms));
+            }
+            // 3. 出力取得
+            let output = null;
+            if (params.get_output !== false) {
+                const outputResult = await this.terminalManager.getOutput(terminalId, undefined, // start_lineはデフォルト（連続読み取り）
+                params.output_lines || 20, params.include_ansi || false, false // include_foreground_process
+                );
+                output = outputResult;
+            }
+            // 4. レスポンス構築
+            const response = {
+                terminal_id: terminalId,
+                success: !inputRejected, // 入力が拒否された場合はfalse
+            };
+            // 入力拒否情報を追加
+            if (inputRejected) {
+                response['input_rejected'] = true;
+                response['reason'] = rejectionReason;
+                if (unreadOutput) {
+                    response['unread_output'] = unreadOutput.output;
+                    response['unread_output_info'] = {
+                        line_count: unreadOutput.line_count,
+                        total_lines: unreadOutput.total_lines,
+                        has_more: unreadOutput.has_more,
+                        start_line: unreadOutput.start_line,
+                        next_start_line: unreadOutput.next_start_line,
+                    };
+                }
+            }
+            if (params.return_terminal_info !== false && terminalInfo) {
+                response['terminal_info'] = terminalInfo;
+            }
+            if (output) {
+                response['output'] = output.output;
+                response['output_info'] = {
+                    line_count: output.line_count,
+                    total_lines: output.total_lines,
+                    has_more: output.has_more,
+                    start_line: output.start_line,
+                    next_start_line: output.next_start_line,
+                };
+            }
+            // 応答レベルに応じて情報を調整
+            if (params.response_level === 'minimal') {
+                return {
+                    terminal_id: terminalId,
+                    success: true,
+                    output: output?.output || null,
+                };
+            }
+            else if (params.response_level === 'full') {
+                // フル情報を含める（すでにresponseに含まれている）
+            }
+            return response;
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    // Command History Management
+    async queryCommandHistory(params) {
+        try {
+            // Handle individual entry reference
+            if (params.entry_id) {
+                const entries = this.historyManager.searchHistory({
+                    limit: 1000, // Get all entries to search for the specific ID
+                });
+                const entry = entries.find((e) => e.execution_id === params.entry_id);
+                if (!entry) {
+                    return {
+                        success: false,
+                        error: `Entry with ID ${params.entry_id} not found`,
+                    };
+                }
+                return {
+                    success: true,
+                    entry: params.include_full_details
+                        ? entry
+                        : {
+                            execution_id: entry.execution_id,
+                            command: entry.command,
+                            timestamp: entry.timestamp,
+                            working_directory: entry.working_directory,
+                            safety_classification: entry.safety_classification,
+                            was_executed: entry.was_executed,
+                            output_summary: entry.output_summary,
+                        },
+                };
+            }
+            // Handle analytics
+            if (params.analytics_type) {
+                const stats = this.historyManager.getHistoryStats();
+                switch (params.analytics_type) {
+                    case 'stats':
+                        return {
+                            success: true,
+                            analytics: {
+                                type: 'stats',
+                                total_entries: stats.totalEntries,
+                                entries_with_evaluation: stats.entriesWithEvaluation,
+                                entries_with_confirmation: stats.entriesWithConfirmation,
+                            },
+                        };
+                    case 'patterns':
+                        return {
+                            success: true,
+                            analytics: {
+                                type: 'patterns',
+                                confirmation_patterns: stats.confirmationPatterns,
+                            },
+                        };
+                    case 'top_commands':
+                        return {
+                            success: true,
+                            analytics: {
+                                type: 'top_commands',
+                                top_commands: stats.topCommands,
+                            },
+                        };
+                }
+            }
+            // Handle search and pagination
+            const searchQuery = {};
+            if (params.command_pattern || params.query) {
+                searchQuery['command'] = params.command_pattern || params.query;
+            }
+            if (params.working_directory) {
+                searchQuery['working_directory'] = params.working_directory;
+            }
+            if (params.was_executed !== undefined) {
+                searchQuery['was_executed'] = params.was_executed;
+            }
+            if (params.safety_classification) {
+                searchQuery['safety_classification'] = params.safety_classification;
+            }
+            // Calculate pagination
+            const offset = (params.page - 1) * params.page_size;
+            searchQuery['limit'] = params.page_size + offset; // Get more to handle offset
+            let results = this.historyManager.searchHistory(searchQuery);
+            // Apply date filtering if specified
+            if (params.date_from || params.date_to) {
+                const fromDate = params.date_from ? new Date(params.date_from) : new Date(0);
+                const toDate = params.date_to ? new Date(params.date_to) : new Date();
+                results = results.filter((entry) => {
+                    const entryDate = new Date(entry.timestamp);
+                    return entryDate >= fromDate && entryDate <= toDate;
+                });
+            }
+            // Apply pagination
+            const totalEntries = results.length;
+            const paginatedResults = results.slice(offset, offset + params.page_size);
+            // Format results
+            const entries = paginatedResults.map((entry) => {
+                if (params.include_full_details) {
+                    return entry;
+                }
+                else {
+                    // Return metadata with IDs for external tool integration
+                    return {
+                        execution_id: entry.execution_id,
+                        command: entry.command,
+                        timestamp: entry.timestamp,
+                        working_directory: entry.working_directory,
+                        safety_classification: entry.safety_classification,
+                        llm_evaluation_result: entry.llm_evaluation_result,
+                        was_executed: entry.was_executed,
+                        resubmission_count: entry.resubmission_count,
+                        output_summary: entry.output_summary,
+                        // IDs for external tool integration
+                        ...(entry.was_executed && {
+                            // These can be used with process_get_execution and read_execution_output
+                            reference_note: 'Use process_get_execution with execution_id for detailed execution info, or read_execution_output for full output',
+                        }),
+                    };
+                }
+            });
+            return {
+                success: true,
+                entries,
+                pagination: {
+                    page: params.page,
+                    page_size: params.page_size,
+                    total_entries: totalEntries,
+                    total_pages: Math.ceil(totalEntries / params.page_size),
+                    has_next: offset + params.page_size < totalEntries,
+                    has_previous: params.page > 1,
+                },
+            };
+        }
+        catch (error) {
+            throw MCPShellError.fromError(error);
+        }
+    }
+    async getCleanupSuggestionsValidated(rawParams) {
+        const params = CleanupSuggestionsParamsSchema.parse(rawParams ?? {});
+        return this.getCleanupSuggestions(params);
+    }
+    async performAutoCleanupValidated(rawParams) {
+        const params = AutoCleanupParamsSchema.parse(rawParams ?? {});
+        return this.performAutoCleanup(params);
+    }
+    async queryCommandHistoryValidated(rawParams) {
+        const params = CommandHistoryQueryParamsSchema.parse(rawParams ?? {});
+        return this.queryCommandHistory(params);
+    }
+    // Dynamic Security Criteria Adjustment
+    // NOTE: MCP-side adjust_criteria method is disabled (security concern)
+    async _adjustCriteria(params) {
+        try {
+            // Validate criteria text
+            if (!params.criteria_text || params.criteria_text.trim().length === 0) {
+                return {
+                    success: false,
+                    error: 'Criteria text cannot be empty',
+                };
+            }
+            // Get current status before modification
+            const statusBefore = await _getCriteriaStatus();
+            // Save criteria with backup option
+            const result = await _saveCriteria(params.criteria_text, params.append_mode || false, params.backup_existing !== false // Default to true
+            );
+            // Get status after modification
+            const statusAfter = await _getCriteriaStatus();
+            return {
+                success: true,
+                message: `Security criteria ${params.append_mode ? 'appended to' : 'updated at'} ${result.criteriaPath}`,
+                details: {
+                    criteria_path: result.criteriaPath,
+                    backup_path: result.backupPath,
+                    append_mode: params.append_mode || false,
+                    backup_created: result.backupPath !== null,
+                    status_before: statusBefore,
+                    status_after: statusAfter,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Failed to adjust criteria: ${error instanceof Error ? error.message : String(error)}`,
+                details: {
+                    error_type: error instanceof Error ? error.constructor.name : 'Unknown',
+                },
+            };
+        }
+    }
+}
+//# sourceMappingURL=shell-tools.js.map