@wonderwhy-er/desktop-commander 0.1.37 → 0.1.39

package/dist/client/replClient.js

@@ -0,0 +1,217 @@
+/**
+ * Client-side utility for interacting with the REPL functionality
+ */
+export class REPLClient {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.sessions = {};
+    }
+    /**
+     * Create a new REPL session for a specific language
+     * @param language - Language for the REPL (python, node, bash)
+     * @param options - Optional configuration
+     * @returns Session information
+     */
+    async createSession(language, options = {}) {
+        try {
+            const response = await this.apiClient.executeCommand('repl.create', {
+                language,
+                options
+            });
+            if (response.success && response.pid) {
+                this.sessions[response.pid] = {
+                    language,
+                    pid: response.pid,
+                    createdAt: new Date()
+                };
+            }
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to create REPL session:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to create REPL session'
+            };
+        }
+    }
+    /**
+     * Execute code in an existing REPL session
+     * @param pid - Process ID of the session
+     * @param code - Code to execute
+     * @param options - Optional execution options
+     * @returns Execution results
+     */
+    async executeCode(pid, code, options = {}) {
+        try {
+            return await this.apiClient.executeCommand('repl.execute', {
+                pid,
+                code,
+                options
+            });
+        }
+        catch (error) {
+            console.error('Failed to execute code:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to execute code'
+            };
+        }
+    }
+    /**
+     * List all active REPL sessions
+     * @returns List of active sessions
+     */
+    async listSessions() {
+        try {
+            return await this.apiClient.executeCommand('repl.list');
+        }
+        catch (error) {
+            console.error('Failed to list REPL sessions:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to list REPL sessions'
+            };
+        }
+    }
+    /**
+     * Close a specific REPL session
+     * @param pid - Process ID to close
+     * @returns Result indicating success
+     */
+    async closeSession(pid) {
+        try {
+            const response = await this.apiClient.executeCommand('repl.close', { pid });
+            if (response.success) {
+                delete this.sessions[pid];
+            }
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to close REPL session:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to close REPL session'
+            };
+        }
+    }
+    /**
+     * Close all idle REPL sessions
+     * @param maxIdleMs - Maximum idle time in milliseconds
+     * @returns Result with number of closed sessions
+     */
+    async closeIdleSessions(maxIdleMs) {
+        try {
+            const response = await this.apiClient.executeCommand('repl.closeIdle', { maxIdleMs });
+            // If successful, refresh our local session cache
+            if (response.success && response.closedCount > 0) {
+                const activeSessionsResponse = await this.listSessions();
+                if (activeSessionsResponse.success) {
+                    // Reset our session tracking
+                    this.sessions = {};
+                    // Add back active sessions
+                    activeSessionsResponse.sessions.forEach((session) => {
+                        this.sessions[session.pid] = {
+                            language: session.language,
+                            pid: session.pid,
+                            createdAt: new Date(session.startTime)
+                        };
+                    });
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to close idle REPL sessions:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to close idle REPL sessions'
+            };
+        }
+    }
+    /**
+     * Execute a multi-line code block in the appropriate REPL session
+     * @param codeBlock - Code block with language marker
+     * @param options - Optional execution options
+     * @returns Execution results
+     */
+    async executeCodeBlock(codeBlock, options = {}) {
+        try {
+            // Parse code block format with language marker
+            // Example: ```python
+            //          print("Hello")
+            //          ```
+            const match = codeBlock.match(/```(\w+)\s*\n([\s\S]+?)```/);
+            if (!match) {
+                return {
+                    success: false,
+                    error: 'Invalid code block format. Use ```language\\ncode```'
+                };
+            }
+            const language = match[1].toLowerCase();
+            const code = match[2].trim();
+            // Find or create session for this language
+            let pid = null;
+            // Look for existing session
+            for (const sessionPid in this.sessions) {
+                if (this.sessions[sessionPid].language === language) {
+                    pid = parseInt(sessionPid);
+                    break;
+                }
+            }
+            // Create new session if needed
+            if (!pid) {
+                const createResult = await this.createSession(language, options);
+                if (!createResult.success) {
+                    return createResult;
+                }
+                pid = createResult.pid;
+            }
+            // Execute the code
+            return await this.executeCode(pid, code, options);
+        }
+        catch (error) {
+            console.error('Failed to execute code block:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to execute code block'
+            };
+        }
+    }
+    /**
+     * Run a simple one-liner code snippet
+     * @param language - The programming language
+     * @param code - Code to execute (single line)
+     * @param options - Optional execution options
+     * @returns Execution results
+     */
+    async runSnippet(language, code, options = {}) {
+        try {
+            // Look for existing session
+            let pid = null;
+            for (const sessionPid in this.sessions) {
+                if (this.sessions[sessionPid].language === language.toLowerCase()) {
+                    pid = parseInt(sessionPid);
+                    break;
+                }
+            }
+            // Create new session if needed
+            if (!pid) {
+                const createResult = await this.createSession(language, options);
+                if (!createResult.success) {
+                    return createResult;
+                }
+                pid = createResult.pid;
+            }
+            // Execute the code
+            return await this.executeCode(pid, code, options);
+        }
+        catch (error) {
+            console.error('Failed to run snippet:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to run snippet'
+            };
+        }
+    }
+}

package/dist/client/sshClient.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Client-side utility for SSH interactions
+ */
+interface ApiClient {
+    executeCommand: (command: string, params?: any) => Promise<any>;
+}
+interface SSHSession {
+    host: string;
+    username?: string;
+    pid: number;
+    createdAt: Date;
+    lastActivity: Date;
+}
+interface SSHOptions {
+    username?: string;
+    port?: number;
+    identity?: string;
+    password?: string;
+    timeout?: number;
+    stopOnError?: boolean;
+}
+export declare class SSHClient {
+    private apiClient;
+    private activeSessions;
+    constructor(apiClient: ApiClient);
+    /**
+     * Connect to an SSH server
+     * @param host - SSH host to connect to
+     * @param options - Connection options
+     * @returns Connection information
+     */
+    connect(host: string, options?: SSHOptions): Promise<any>;
+    /**
+     * Execute a command on the remote server
+     * @param pid - Process ID of the SSH session
+     * @param command - Command to execute
+     * @param options - Execution options
+     * @returns Command results
+     */
+    executeCommand(pid: number | string, command: string, options?: SSHOptions): Promise<any>;
+    /**
+     * Execute a command on a specific host (creates session if needed)
+     * @param host - SSH host
+     * @param command - Command to execute
+     * @param options - Connection and execution options
+     * @returns Command results
+     */
+    executeCommandOnHost(host: string, command: string, options?: SSHOptions): Promise<any>;
+    /**
+     * Execute multiple commands in sequence
+     * @param pid - Process ID of the SSH session
+     * @param commands - List of commands to execute
+     * @param options - Execution options
+     * @returns Results for each command
+     */
+    executeSequence(pid: number | string, commands: string[], options?: SSHOptions): Promise<any>;
+    /**
+     * Execute a multi-line script as separate commands
+     * @param pid - Process ID of the SSH session
+     * @param script - Multi-line script
+     * @param options - Execution options
+     * @returns Script execution results
+     */
+    executeScript(pid: number | string, script: string, options?: SSHOptions): Promise<any>;
+    /**
+     * Close an SSH session
+     * @param pid - Process ID to close
+     * @returns Result indicating success
+     */
+    disconnect(pid: number | string): Promise<any>;
+    /**
+     * List all active SSH sessions
+     * @returns List of active sessions
+     */
+    listSessions(): SSHSession[];
+    /**
+     * Close all SSH sessions
+     * @returns Result with number of closed sessions
+     */
+    disconnectAll(): Promise<any>;
+}
+export {};

package/dist/client/sshClient.js

@@ -0,0 +1,200 @@
+/**
+ * Client-side utility for SSH interactions
+ */
+export class SSHClient {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.activeSessions = {};
+    }
+    /**
+     * Connect to an SSH server
+     * @param host - SSH host to connect to
+     * @param options - Connection options
+     * @returns Connection information
+     */
+    async connect(host, options = {}) {
+        try {
+            // Check if we already have an active session for this host
+            for (const pid in this.activeSessions) {
+                const session = this.activeSessions[pid];
+                if (session.host === host && session.username === options.username) {
+                    return {
+                        success: true,
+                        pid: parseInt(pid),
+                        host,
+                        username: options.username,
+                        message: `Reusing existing SSH session to ${host} (PID: ${pid})`
+                    };
+                }
+            }
+            // Create new session
+            const response = await this.apiClient.executeCommand('ssh.create', {
+                host,
+                ...options
+            });
+            if (response.success && response.pid) {
+                this.activeSessions[response.pid] = {
+                    host,
+                    username: options.username,
+                    pid: response.pid,
+                    createdAt: new Date(),
+                    lastActivity: new Date()
+                };
+            }
+            return response;
+        }
+        catch (error) {
+            console.error('SSH connection failed:', error);
+            return {
+                success: false,
+                error: error.message || 'SSH connection failed'
+            };
+        }
+    }
+    /**
+     * Execute a command on the remote server
+     * @param pid - Process ID of the SSH session
+     * @param command - Command to execute
+     * @param options - Execution options
+     * @returns Command results
+     */
+    async executeCommand(pid, command, options = {}) {
+        try {
+            // Update last activity time
+            const pidNum = typeof pid === 'string' ? parseInt(pid) : pid;
+            if (this.activeSessions[pidNum]) {
+                this.activeSessions[pidNum].lastActivity = new Date();
+            }
+            return await this.apiClient.executeCommand('ssh.execute', {
+                pid,
+                command,
+                options
+            });
+        }
+        catch (error) {
+            console.error('SSH command execution failed:', error);
+            return {
+                success: false,
+                error: error.message || 'SSH command execution failed'
+            };
+        }
+    }
+    /**
+     * Execute a command on a specific host (creates session if needed)
+     * @param host - SSH host
+     * @param command - Command to execute
+     * @param options - Connection and execution options
+     * @returns Command results
+     */
+    async executeCommandOnHost(host, command, options = {}) {
+        try {
+            // First connect (or reuse connection)
+            const connResult = await this.connect(host, options);
+            if (!connResult.success) {
+                return connResult;
+            }
+            // Then execute the command
+            const result = await this.executeCommand(connResult.pid, command, options);
+            // Include host info in the result
+            return {
+                ...result,
+                host,
+                pid: connResult.pid
+            };
+        }
+        catch (error) {
+            console.error('SSH command execution failed:', error);
+            return {
+                success: false,
+                error: error.message || 'SSH command execution failed'
+            };
+        }
+    }
+    /**
+     * Execute multiple commands in sequence
+     * @param pid - Process ID of the SSH session
+     * @param commands - List of commands to execute
+     * @param options - Execution options
+     * @returns Results for each command
+     */
+    async executeSequence(pid, commands, options = {}) {
+        const results = [];
+        for (const command of commands) {
+            const result = await this.executeCommand(pid, command, options);
+            results.push(result);
+            // Stop on first error if requested
+            if (options.stopOnError && !result.success) {
+                break;
+            }
+        }
+        return {
+            success: results.every(r => r.success),
+            results,
+            completedCommands: results.length
+        };
+    }
+    /**
+     * Execute a multi-line script as separate commands
+     * @param pid - Process ID of the SSH session
+     * @param script - Multi-line script
+     * @param options - Execution options
+     * @returns Script execution results
+     */
+    async executeScript(pid, script, options = {}) {
+        const commands = script
+            .split('\n')
+            .map(line => line.trim())
+            .filter(line => line && !line.startsWith('#'));
+        return await this.executeSequence(pid, commands, options);
+    }
+    /**
+     * Close an SSH session
+     * @param pid - Process ID to close
+     * @returns Result indicating success
+     */
+    async disconnect(pid) {
+        try {
+            const response = await this.apiClient.executeCommand('repl.close', {
+                pid
+            });
+            const pidNum = typeof pid === 'string' ? parseInt(pid) : pid;
+            if (response.success) {
+                delete this.activeSessions[pidNum];
+            }
+            return response;
+        }
+        catch (error) {
+            console.error('Failed to close SSH session:', error);
+            return {
+                success: false,
+                error: error.message || 'Failed to close SSH session'
+            };
+        }
+    }
+    /**
+     * List all active SSH sessions
+     * @returns List of active sessions
+     */
+    listSessions() {
+        return Object.values(this.activeSessions);
+    }
+    /**
+     * Close all SSH sessions
+     * @returns Result with number of closed sessions
+     */
+    async disconnectAll() {
+        const pids = Object.keys(this.activeSessions);
+        let closedCount = 0;
+        for (const pid of pids) {
+            const result = await this.disconnect(pid);
+            if (result.success) {
+                closedCount++;
+            }
+        }
+        return {
+            success: true,
+            closedCount,
+            message: `Closed ${closedCount} SSH session(s)`
+        };
+    }
+}

package/dist/handlers/repl-handlers.d.ts

@@ -0,0 +1,21 @@
+import { ServerResult } from '../types.js';
+/**
+ * Handle create_repl_session command
+ */
+export declare function handleCreateREPLSession(args: unknown): Promise<ServerResult>;
+/**
+ * Handle execute_repl_code command
+ */
+export declare function handleExecuteREPLCode(args: unknown): Promise<ServerResult>;
+/**
+ * Handle terminate_repl_session command
+ */
+export declare function handleTerminateREPLSession(args: unknown): Promise<ServerResult>;
+/**
+ * Handle list_repl_sessions command
+ */
+export declare function handleListREPLSessions(args?: unknown): Promise<ServerResult>;
+/**
+ * Handle get_repl_session_info command
+ */
+export declare function handleGetREPLSessionInfo(args: unknown): Promise<ServerResult>;

package/dist/handlers/repl-handlers.js

@@ -0,0 +1,37 @@
+import { createREPLSession, executeREPLCode, terminateREPLSession, listREPLSessions, getREPLSessionInfo } from '../tools/repl.js';
+import { CreateREPLSessionArgsSchema, ExecuteREPLCodeArgsSchema, TerminateREPLSessionArgsSchema, ListREPLSessionsArgsSchema, GetREPLSessionInfoArgsSchema } from '../tools/schemas.js';
+/**
+ * Handle create_repl_session command
+ */
+export async function handleCreateREPLSession(args) {
+    const parsed = CreateREPLSessionArgsSchema.parse(args);
+    return createREPLSession(parsed);
+}
+/**
+ * Handle execute_repl_code command
+ */
+export async function handleExecuteREPLCode(args) {
+    const parsed = ExecuteREPLCodeArgsSchema.parse(args);
+    return executeREPLCode(parsed);
+}
+/**
+ * Handle terminate_repl_session command
+ */
+export async function handleTerminateREPLSession(args) {
+    const parsed = TerminateREPLSessionArgsSchema.parse(args);
+    return terminateREPLSession(parsed);
+}
+/**
+ * Handle list_repl_sessions command
+ */
+export async function handleListREPLSessions(args = {}) {
+    const parsed = ListREPLSessionsArgsSchema.parse(args);
+    return listREPLSessions(parsed);
+}
+/**
+ * Handle get_repl_session_info command
+ */
+export async function handleGetREPLSessionInfo(args) {
+    const parsed = GetREPLSessionInfoArgsSchema.parse(args);
+    return getREPLSessionInfo(parsed);
+}

package/dist/handlers/replCommandHandler.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Initialize the REPL manager with a terminal manager instance
+ * @param terminalManager - The terminal manager instance
+ */
+export declare function initializeREPLManager(terminalManager: any): void;
+interface REPLSessionParams {
+    language: string;
+    options?: any;
+}
+interface ExecuteCodeParams {
+    pid: number | string;
+    code: string;
+    options?: any;
+}
+interface SSHSessionParams {
+    host: string;
+    username?: string;
+    port?: number;
+    identity?: string;
+    password?: string;
+    options?: any;
+}
+interface CommandParams {
+    pid: number | string;
+    command: string;
+    options?: any;
+}
+interface IdleSessionParams {
+    maxIdleMs?: number;
+}
+/**
+ * Command handler for REPL-related operations
+ */
+export declare const replCommandHandler: {
+    /**
+     * Create a new REPL session
+     * @param params - Command parameters
+     * @returns Result object with session PID
+     */
+    createREPLSession: (params: REPLSessionParams) => Promise<{
+        success: boolean;
+        pid: number;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        pid?: undefined;
+        message?: undefined;
+    }>;
+    /**
+     * Execute code in an existing REPL session
+     * @param params - Command parameters
+     * @returns Result with execution output
+     */
+    executeREPLCode: (params: ExecuteCodeParams) => Promise<any>;
+    /**
+     * Create a new SSH session
+     * @param params - Command parameters
+     * @returns Result object with session PID
+     */
+    createSSHSession: (params: SSHSessionParams) => Promise<{
+        success: boolean;
+        pid: number;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        pid?: undefined;
+        message?: undefined;
+    }>;
+    /**
+     * Execute a command in an SSH session
+     * @param params - Command parameters
+     * @returns Result with execution output
+     */
+    executeSSHCommand: (params: CommandParams) => Promise<any>;
+    /**
+     * List all active REPL sessions
+     * @returns List of active sessions
+     */
+    listREPLSessions: () => {
+        success: boolean;
+        sessions: any[];
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        sessions?: undefined;
+    };
+    /**
+     * Close a specific REPL session
+     * @param params - Command parameters
+     * @returns Result indicating success
+     */
+    closeREPLSession: (params: {
+        pid: number | string;
+    }) => Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        message?: undefined;
+    }>;
+    /**
+     * Close all idle REPL sessions
+     * @param params - Command parameters
+     * @returns Result with number of closed sessions
+     */
+    closeIdleREPLSessions: (params?: IdleSessionParams) => Promise<{
+        success: boolean;
+        closedCount: number;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        closedCount?: undefined;
+        message?: undefined;
+    }>;
+};
+export {};