@wonderwhy-er/desktop-commander 0.1.37 → 0.1.39

package/dist/handlers/replCommandHandler.js

@@ -0,0 +1,255 @@
+import { REPLSessionManager } from '../REPLSessionManager.js';
+let replManager = null;
+/**
+ * Initialize the REPL manager with a terminal manager instance
+ * @param terminalManager - The terminal manager instance
+ */
+export function initializeREPLManager(terminalManager) {
+    if (!replManager) {
+        replManager = new REPLSessionManager(terminalManager);
+    }
+}
+/**
+ * Command handler for REPL-related operations
+ */
+export const replCommandHandler = {
+    /**
+     * Create a new REPL session
+     * @param params - Command parameters
+     * @returns Result object with session PID
+     */
+    createREPLSession: async (params) => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const language = params.language;
+            if (!language) {
+                return {
+                    success: false,
+                    error: "Language parameter is required"
+                };
+            }
+            const pid = await replManager.createSession(language, params.options || {});
+            return {
+                success: true,
+                pid,
+                message: `${language} REPL session started with PID ${pid}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to create REPL session"
+            };
+        }
+    },
+    /**
+     * Execute code in an existing REPL session
+     * @param params - Command parameters
+     * @returns Result with execution output
+     */
+    executeREPLCode: async (params) => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const { pid, code } = params;
+            if (!pid || !code) {
+                return {
+                    success: false,
+                    error: "Both pid and code parameters are required"
+                };
+            }
+            const result = await replManager.executeCode(typeof pid === 'string' ? parseInt(pid) : pid, code, params.options || {});
+            return {
+                success: true,
+                ...result
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to execute code in REPL session"
+            };
+        }
+    },
+    /**
+     * Create a new SSH session
+     * @param params - Command parameters
+     * @returns Result object with session PID
+     */
+    createSSHSession: async (params) => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const { host, username, port, identity, password } = params;
+            if (!host) {
+                return {
+                    success: false,
+                    error: "Host parameter is required"
+                };
+            }
+            const options = {
+                username,
+                port,
+                identity,
+                password,
+                ...(params.options || {})
+            };
+            const pid = await replManager.createSSHSession(host, options);
+            return {
+                success: true,
+                pid,
+                message: `SSH session to ${host} started with PID ${pid}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to create SSH session"
+            };
+        }
+    },
+    /**
+     * Execute a command in an SSH session
+     * @param params - Command parameters
+     * @returns Result with execution output
+     */
+    executeSSHCommand: async (params) => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const { pid, command } = params;
+            if (!pid || !command) {
+                return {
+                    success: false,
+                    error: "Both pid and command parameters are required"
+                };
+            }
+            // For SSH, we use the same sendAndReadREPL method but specify 'ssh' as the language
+            const parsedPid = typeof pid === 'string' ? parseInt(pid) : pid;
+            const session = replManager.listSessions().find(s => s.pid === parsedPid);
+            if (!session || session.language !== 'ssh') {
+                return {
+                    success: false,
+                    error: "Invalid SSH session PID"
+                };
+            }
+            const result = await replManager.sendAndReadREPL(parsedPid, command, 'ssh', params.options?.timeout || 10000);
+            return {
+                success: true,
+                ...result
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to execute command in SSH session"
+            };
+        }
+    },
+    /**
+     * List all active REPL sessions
+     * @returns List of active sessions
+     */
+    listREPLSessions: () => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const sessions = replManager.listSessions();
+            return {
+                success: true,
+                sessions
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to list REPL sessions"
+            };
+        }
+    },
+    /**
+     * Close a specific REPL session
+     * @param params - Command parameters
+     * @returns Result indicating success
+     */
+    closeREPLSession: async (params) => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const { pid } = params;
+            if (!pid) {
+                return {
+                    success: false,
+                    error: "PID parameter is required"
+                };
+            }
+            const parsedPid = typeof pid === 'string' ? parseInt(pid) : pid;
+            const success = await replManager.closeSession(parsedPid);
+            return {
+                success,
+                message: success
+                    ? `REPL session with PID ${pid} closed successfully`
+                    : `Failed to close REPL session with PID ${pid}`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to close REPL session"
+            };
+        }
+    },
+    /**
+     * Close all idle REPL sessions
+     * @param params - Command parameters
+     * @returns Result with number of closed sessions
+     */
+    closeIdleREPLSessions: async (params) => {
+        try {
+            if (!replManager) {
+                return {
+                    success: false,
+                    error: "REPL Manager not initialized"
+                };
+            }
+            const maxIdleMs = params?.maxIdleMs || 30 * 60 * 1000; // Default 30 minutes
+            const closedCount = await replManager.closeIdleSessions(maxIdleMs);
+            return {
+                success: true,
+                closedCount,
+                message: `Closed ${closedCount} idle REPL session(s)`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || "Failed to close idle REPL sessions"
+            };
+        }
+    }
+};

package/dist/handlers/replCommandHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/handlers/replCommandHandler.test.js

@@ -0,0 +1,103 @@
+import { expect } from 'chai';
+import { describe, it, beforeEach, afterEach } from 'mocha';
+import * as sinon from 'sinon';
+import { initializeREPLManager, replCommandHandler } from './replCommandHandler';
+describe('REPL Command Handler', () => {
+    let mockSessionManager;
+    let sandbox;
+    beforeEach(() => {
+        // Create a sinon sandbox for test isolation
+        sandbox = sinon.createSandbox();
+        // Create mock for REPLSessionManager
+        mockSessionManager = {
+            createSession: sandbox.stub().resolves(12345),
+            executeCode: sandbox.stub().resolves({
+                success: true,
+                output: 'test output'
+            }),
+            createSSHSession: sandbox.stub().resolves(54321),
+            sendAndReadREPL: sandbox.stub().resolves({
+                success: true,
+                output: 'ssh output'
+            }),
+            listSessions: sandbox.stub().returns([
+                { pid: 12345, language: 'node' },
+                { pid: 54321, language: 'ssh' }
+            ]),
+            closeSession: sandbox.stub().resolves(true),
+            closeIdleSessions: sandbox.stub().resolves(2)
+        };
+        // Create a mock terminal manager
+        const mockTerminalManager = {};
+        // Use a more direct approach to set up the testing environment
+        // Override the module's private replManager variable with our mock
+        global.replManager = mockSessionManager;
+        initializeREPLManager(mockTerminalManager);
+    });
+    afterEach(() => {
+        // Restore all stubbed methods
+        sandbox.restore();
+        // Reset the module state
+        global.replManager = null;
+    });
+    it('should create a REPL session', async () => {
+        const result = await replCommandHandler.createREPLSession({
+            language: 'node'
+        });
+        expect(result.success).to.be.true;
+        expect(result.pid).to.equal(12345);
+    });
+    it('should execute code in a REPL session', async () => {
+        const result = await replCommandHandler.executeREPLCode({
+            pid: 12345,
+            code: 'console.log("test")'
+        });
+        expect(result.success).to.be.true;
+        expect(result.output).to.equal('test output');
+    });
+    it('should create an SSH session', async () => {
+        const result = await replCommandHandler.createSSHSession({
+            host: 'example.com',
+            username: 'user'
+        });
+        expect(result.success).to.be.true;
+        expect(result.pid).to.equal(54321);
+    });
+    it('should execute a command in an SSH session', async () => {
+        const result = await replCommandHandler.executeSSHCommand({
+            pid: 54321,
+            command: 'ls -la'
+        });
+        expect(result.success).to.be.true;
+        expect(result.output).to.equal('ssh output');
+    });
+    it('should list all REPL sessions', () => {
+        const result = replCommandHandler.listREPLSessions();
+        expect(result.success).to.be.true;
+        expect(result.sessions).to.have.length(2);
+        expect(result.sessions[0].pid).to.equal(12345);
+        expect(result.sessions[1].pid).to.equal(54321);
+    });
+    it('should close a REPL session', async () => {
+        const result = await replCommandHandler.closeREPLSession({
+            pid: 12345
+        });
+        expect(result.success).to.be.true;
+    });
+    it('should close idle REPL sessions', async () => {
+        const result = await replCommandHandler.closeIdleREPLSessions({
+            maxIdleMs: 3600000 // 1 hour
+        });
+        expect(result.success).to.be.true;
+        expect(result.closedCount).to.equal(2);
+    });
+    it('should handle errors when REPL manager is not initialized', async () => {
+        // Reset the handler to simulate uninitialized state
+        initializeREPLManager(null);
+        const result = await replCommandHandler.createREPLSession({
+            language: 'node'
+        });
+        expect(result.success).to.be.false;
+        expect(result.error).to.equal('REPL Manager not initialized');
+    });
+});

package/dist/index.js

@@ -45,13 +45,12 @@ async function runSetup() {
 }
 async function runServer() {
     try {
-        const transport = new FilteredStdioServerTransport();
-        console.log("start");
         // Check if first argument is "setup"
         if (process.argv[2] === 'setup') {
             await runSetup();
             return;
         }
+        const transport = new FilteredStdioServerTransport();
         // Handle uncaught exceptions
         process.on('uncaughtException', async (error) => {
             const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/repl-manager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Execution result from a REPL command
+ */
+interface REPLExecutionResult {
+    success: boolean;
+    output: string | null;
+    error?: string;
+    timeout: boolean;
+}
+/**
+ * Options for executing code in a REPL
+ */
+interface REPLExecuteOptions {
+    timeout?: number;
+    waitForPrompt?: boolean;
+    ignoreErrors?: boolean;
+    multiline?: boolean;
+}
+/**
+ * Manager for REPL (Read-Eval-Print Loop) sessions
+ * Provides a higher-level API for working with interactive programming environments
+ */
+export declare class REPLManager {
+    private sessions;
+    private readonly languageConfigs;
+    /**
+     * Calculate an appropriate timeout based on code complexity
+     */
+    private calculateTimeout;
+    /**
+     * Detect when a REPL is ready for input by looking for prompt patterns
+     */
+    private isReadyForInput;
+    /**
+     * Detect errors in REPL output
+     */
+    private detectErrors;
+    /**
+     * Create a new REPL session for the specified language
+     */
+    createSession(language: string, timeout?: number): Promise<number>;
+    /**
+     * Send and read REPL output with a timeout
+     * This combines sending input and reading output in a single operation
+     */
+    sendAndReadREPL(pid: number, input: string, options?: REPLExecuteOptions): Promise<REPLExecutionResult>;
+    /**
+     * Execute a code block in a REPL session
+     */
+    executeCode(pid: number, code: string, options?: REPLExecuteOptions): Promise<REPLExecutionResult>;
+    /**
+     * Terminate a REPL session
+     */
+    terminateSession(pid: number): Promise<boolean>;
+    /**
+     * List all active REPL sessions
+     */
+    listSessions(): Array<{
+        pid: number;
+        language: string;
+        runtime: number;
+    }>;
+    /**
+     * Get information about a specific REPL session
+     */
+    getSessionInfo(pid: number): {
+        pid: number;
+        language: string;
+        runtime: number;
+    } | null;
+}
+export declare const replManager: REPLManager;
+export {};