@wonderwhy-er/desktop-commander 0.2.2 → 0.2.4

package/dist/terminal-manager.js

@@ -2,11 +2,37 @@ import { spawn } from 'child_process';
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 import { configManager } from './config-manager.js';
 import { capture } from "./utils/capture.js";
+import { analyzeProcessState } from './utils/process-detection.js';
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
         this.completedSessions = new Map();
     }
+    /**
+     * Send input to a running process
+     * @param pid Process ID
+     * @param input Text to send to the process
+     * @returns Whether input was successfully sent
+     */
+    sendInputToProcess(pid, input) {
+        const session = this.sessions.get(pid);
+        if (!session) {
+            return false;
+        }
+        try {
+            if (session.process.stdin && !session.process.stdin.destroyed) {
+                // Ensure input ends with a newline for most REPLs
+                const inputWithNewline = input.endsWith('\n') ? input : input + '\n';
+                session.process.stdin.write(inputWithNewline);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error(`Error sending input to process ${pid}:`, error);
+            return false;
+        }
+    }
     async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT, shell) {
         // Get the shell from config if not specified
         let shellToUse = shell;
@@ -20,13 +46,26 @@ export class TerminalManager {
                 shellToUse = true;
             }
         }
+        // For REPL interactions, we need to ensure stdin, stdout, and stderr are properly configured
+        // Note: No special stdio options needed here, Node.js handles pipes by default
+        // Enhance SSH commands automatically
+        let enhancedCommand = command;
+        if (command.trim().startsWith('ssh ') && !command.includes(' -t')) {
+            enhancedCommand = command.replace(/^ssh /, 'ssh -t ');
+            console.log(`Enhanced SSH command: ${enhancedCommand}`);
+        }
         const spawnOptions = {
-            shell: shellToUse
+            shell: shellToUse,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color' // Better terminal compatibility
+            }
         };
-        const process = spawn(command, [], spawnOptions);
+        // Spawn the process with an empty array of arguments and our options
+        const childProcess = spawn(enhancedCommand, [], spawnOptions);
         let output = '';
-        // Ensure process.pid is defined before proceeding
-        if (!process.pid) {
+        // Ensure childProcess.pid is defined before proceeding
+        if (!childProcess.pid) {
             // Return a consistent error object instead of throwing
             return {
                 pid: -1, // Use -1 to indicate an error state
@@ -35,37 +74,73 @@ export class TerminalManager {
             };
         }
         const session = {
-            pid: process.pid,
-            process,
+            pid: childProcess.pid,
+            process: childProcess,
             lastOutput: '',
             isBlocked: false,
             startTime: new Date()
         };
-        this.sessions.set(process.pid, session);
+        this.sessions.set(childProcess.pid, session);
         return new Promise((resolve) => {
-            process.stdout.on('data', (data) => {
+            let resolved = false;
+            let periodicCheck = null;
+            // Quick prompt patterns for immediate detection
+            const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
+            const resolveOnce = (result) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                if (periodicCheck)
+                    clearInterval(periodicCheck);
+                resolve(result);
+            };
+            childProcess.stdout.on('data', (data) => {
                 const text = data.toString();
                 output += text;
                 session.lastOutput += text;
+                // Immediate check for obvious prompts
+                if (quickPromptPatterns.test(text)) {
+                    session.isBlocked = true;
+                    resolveOnce({
+                        pid: childProcess.pid,
+                        output,
+                        isBlocked: true
+                    });
+                }
             });
-            process.stderr.on('data', (data) => {
+            childProcess.stderr.on('data', (data) => {
                 const text = data.toString();
                 output += text;
                 session.lastOutput += text;
             });
+            // Periodic comprehensive check every 100ms
+            periodicCheck = setInterval(() => {
+                if (output.trim()) {
+                    const processState = analyzeProcessState(output, childProcess.pid);
+                    if (processState.isWaitingForInput) {
+                        session.isBlocked = true;
+                        resolveOnce({
+                            pid: childProcess.pid,
+                            output,
+                            isBlocked: true
+                        });
+                    }
+                }
+            }, 100);
+            // Timeout fallback
             setTimeout(() => {
                 session.isBlocked = true;
-                resolve({
-                    pid: process.pid,
+                resolveOnce({
+                    pid: childProcess.pid,
                     output,
                     isBlocked: true
                 });
             }, timeoutMs);
-            process.on('exit', (code) => {
-                if (process.pid) {
+            childProcess.on('exit', (code) => {
+                if (childProcess.pid) {
                     // Store completed session before removing active session
-                    this.completedSessions.set(process.pid, {
-                        pid: process.pid,
+                    this.completedSessions.set(childProcess.pid, {
+                        pid: childProcess.pid,
                         output: output + session.lastOutput, // Combine all output
                         exitCode: code,
                         startTime: session.startTime,
@@ -76,10 +151,10 @@ export class TerminalManager {
                         const oldestKey = Array.from(this.completedSessions.keys())[0];
                         this.completedSessions.delete(oldestKey);
                     }
-                    this.sessions.delete(process.pid);
+                    this.sessions.delete(childProcess.pid);
                 }
-                resolve({
-                    pid: process.pid,
+                resolveOnce({
+                    pid: childProcess.pid,
                     output,
                     isBlocked: false
                 });

package/dist/tools/client.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Simple tool to get current client information
+ */
+export declare function getCurrentClient(): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/client.js

@@ -0,0 +1,13 @@
+/**
+ * Simple tool to get current client information
+ */
+import { currentClient } from '../server.js';
+export async function getCurrentClient() {
+    return {
+        content: [{
+                type: "text",
+                text: `Current client: ${currentClient.name} v${currentClient.version}`
+            }],
+        isError: false,
+    };
+}

package/dist/tools/config.d.ts

@@ -1,5 +1,5 @@
 /**
- * Get the entire config
+ * Get the entire config including system information
  */
 export declare function getConfig(): Promise<{
     content: {

package/dist/tools/config.js

@@ -1,17 +1,35 @@
 import { configManager } from '../config-manager.js';
 import { SetConfigValueArgsSchema } from './schemas.js';
+import { getSystemInfo } from '../utils/system-info.js';
+import { currentClient } from '../server.js';
 /**
- * Get the entire config
+ * Get the entire config including system information
  */
 export async function getConfig() {
     console.error('getConfig called');
     try {
         const config = await configManager.getConfig();
-        console.error(`getConfig result: ${JSON.stringify(config, null, 2)}`);
+        // Add system information and current client to the config response
+        const systemInfo = getSystemInfo();
+        const configWithSystemInfo = {
+            ...config,
+            currentClient,
+            systemInfo: {
+                platform: systemInfo.platform,
+                platformName: systemInfo.platformName,
+                defaultShell: systemInfo.defaultShell,
+                pathSeparator: systemInfo.pathSeparator,
+                isWindows: systemInfo.isWindows,
+                isMacOS: systemInfo.isMacOS,
+                isLinux: systemInfo.isLinux,
+                examplePaths: systemInfo.examplePaths
+            }
+        };
+        console.error(`getConfig result: ${JSON.stringify(configWithSystemInfo, null, 2)}`);
         return {
             content: [{
                     type: "text",
-                    text: `Current configuration:\n${JSON.stringify(config, null, 2)}`
+                    text: `Current configuration:\n${JSON.stringify(configWithSystemInfo, null, 2)}`
                 }],
         };
     }

package/dist/tools/edit.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from './filesystem.js';
+import { writeFile, readFileInternal, validatePath } from './filesystem.js';
 import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
 import { EditBlockArgsSchema } from "./schemas.js";
@@ -86,8 +86,9 @@ export async function performSearchReplace(filePath, block, expectedReplacements
                 }],
         };
     }
-    // Read file as plain string
-    const { content } = await readFile(filePath, false, 0, Number.MAX_SAFE_INTEGER);
+    // Read file directly to preserve line endings - critical for edit operations
+    const validPath = await validatePath(filePath);
+    const content = await readFileInternal(validPath, 0, Number.MAX_SAFE_INTEGER);
     // Make sure content is a string
     if (typeof content !== 'string') {
         capture('server_edit_block_content_not_string', { fileExtension: fileExtension, expectedReplacements });

package/dist/tools/environment.d.ts

@@ -0,0 +1,55 @@
+export declare function getEnvironmentInfo(): {
+    processInfo: {
+        pid: number;
+        ppid: number;
+        cwd: string;
+        nodeVersion: string;
+        versions: NodeJS.ProcessVersions;
+        argv: string[];
+        uptime: number;
+        memoryUsage: NodeJS.MemoryUsage;
+        execPath: string;
+        execArgv: string[];
+        platform: NodeJS.Platform;
+        arch: NodeJS.Architecture;
+        title: string;
+    };
+    systemEnvironment: {
+        platform: NodeJS.Platform;
+        arch: string;
+        hostname: string;
+        totalmem: number;
+        freemem: number;
+        cpus: import("os").CpuInfo[];
+        userInfo: import("os").UserInfo<string>;
+        networkInterfaces: NodeJS.Dict<import("os").NetworkInterfaceInfo[]>;
+        environmentVariables: NodeJS.ProcessEnv;
+        loadavg: number[];
+        uptime: number;
+        tmpdir: string;
+        homedir: string;
+        endianness: "BE" | "LE";
+        release: string;
+        type: string;
+    };
+    runtimeContext: {
+        timestamp: string;
+        timezone: string;
+        locale: string;
+        executionTime: number;
+    };
+    error?: undefined;
+} | {
+    error: string;
+    processInfo: {
+        pid: number;
+        cwd: string;
+    };
+    systemEnvironment: {
+        platform: NodeJS.Platform;
+    };
+    runtimeContext: {
+        timestamp: string;
+        executionTime: number;
+    };
+};

package/dist/tools/environment.js

@@ -0,0 +1,65 @@
+import { platform, arch, totalmem, freemem, cpus, userInfo, networkInterfaces, hostname, loadavg, uptime as osUptime, tmpdir, homedir, endianness, release, type } from 'os';
+import { cwd, env, argv, pid, ppid, version, versions, memoryUsage, uptime } from 'process';
+export function getEnvironmentInfo() {
+    const startTime = Date.now();
+    try {
+        // Process Information
+        const processInfo = {
+            pid: pid,
+            ppid: ppid,
+            cwd: cwd(),
+            nodeVersion: version,
+            versions: versions,
+            argv: argv,
+            uptime: uptime(),
+            memoryUsage: memoryUsage(),
+            execPath: process.execPath,
+            execArgv: process.execArgv,
+            platform: process.platform,
+            arch: process.arch,
+            title: process.title
+        };
+        // System Environment
+        const systemEnvironment = {
+            platform: platform(),
+            arch: arch(),
+            hostname: hostname(),
+            totalmem: totalmem(),
+            freemem: freemem(),
+            cpus: cpus(),
+            userInfo: userInfo(),
+            networkInterfaces: networkInterfaces(),
+            environmentVariables: env,
+            loadavg: loadavg(),
+            uptime: osUptime(),
+            tmpdir: tmpdir(),
+            homedir: homedir(),
+            endianness: endianness(),
+            release: release(),
+            type: type()
+        };
+        // Runtime Context
+        const runtimeContext = {
+            timestamp: new Date().toISOString(),
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            locale: Intl.DateTimeFormat().resolvedOptions().locale,
+            executionTime: Date.now() - startTime
+        };
+        return {
+            processInfo,
+            systemEnvironment,
+            runtimeContext
+        };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error.message : String(error),
+            processInfo: { pid, cwd: cwd() },
+            systemEnvironment: { platform: platform() },
+            runtimeContext: {
+                timestamp: new Date().toISOString(),
+                executionTime: Date.now() - startTime
+            }
+        };
+    }
+}

package/dist/tools/feedback.d.ts

@@ -0,0 +1,8 @@
+import { ServerResult } from '../types.js';
+interface FeedbackParams {
+}
+/**
+ * Open feedback form in browser with optional pre-filled data
+ */
+export declare function giveFeedbackToDesktopCommander(params?: FeedbackParams): Promise<ServerResult>;
+export {};

package/dist/tools/feedback.js

@@ -0,0 +1,132 @@
+import { usageTracker } from '../utils/usageTracker.js';
+import { capture } from '../utils/capture.js';
+import { configManager } from '../config-manager.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import * as os from 'os';
+const execAsync = promisify(exec);
+/**
+ * Open feedback form in browser with optional pre-filled data
+ */
+export async function giveFeedbackToDesktopCommander(params = {}) {
+    try {
+        // Get usage stats for context
+        const stats = await usageTracker.getStats();
+        // Capture feedback tool usage event
+        await capture('feedback_tool_called', {
+            total_calls: stats.totalToolCalls,
+            successful_calls: stats.successfulCalls,
+            failed_calls: stats.failedCalls,
+            days_since_first_use: Math.floor((Date.now() - stats.firstUsed) / (1000 * 60 * 60 * 24)),
+            total_sessions: stats.totalSessions,
+            platform: os.platform(),
+        });
+        // Build Tally.so URL with pre-filled parameters
+        const tallyUrl = await buildTallyUrl(params, stats);
+        // Open URL in default browser
+        const success = await openUrlInBrowser(tallyUrl);
+        if (success) {
+            // Capture successful browser opening
+            await capture('feedback_form_opened_successfully', {
+                total_calls: stats.totalToolCalls,
+                platform: os.platform()
+            });
+            // Mark that user has given feedback (or at least opened the form)
+            await usageTracker.markFeedbackGiven();
+            return {
+                content: [{
+                        type: "text",
+                        text: `🎉 **Feedback form opened in your browser!**\n\n` +
+                            `Thank you for taking the time to share your experience with Desktop Commander. ` +
+                            `Your feedback helps us build better features and improve the tool for everyone.\n\n` +
+                            `The form has been pre-filled with the information you provided. ` +
+                            `You can modify or add any additional details before submitting.\n\n` +
+                            `**Form URL**: ${tallyUrl.length > 100 ? tallyUrl.substring(0, 100) + '...' : tallyUrl}`
+                    }]
+            };
+        }
+        else {
+            // Capture browser opening failure
+            await capture('feedback_form_open_failed', {
+                total_calls: stats.totalToolCalls,
+                platform: os.platform(),
+                error_type: 'browser_open_failed'
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `⚠️ **Couldn't open browser automatically**\n\n` +
+                            `Please copy and paste this URL into your browser to access the feedback form:\n\n` +
+                            `${tallyUrl}\n\n` +
+                            `The form has been pre-filled with your information. Thank you for your feedback!`
+                    }]
+            };
+        }
+    }
+    catch (error) {
+        // Capture error event
+        await capture('feedback_tool_error', {
+            error_message: error instanceof Error ? error.message : String(error),
+            error_type: error instanceof Error ? error.constructor.name : 'unknown'
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ **Error opening feedback form**: ${error instanceof Error ? error.message : String(error)}\n\n` +
+                        `You can still access our feedback form directly at: https://tally.so/r/mYB6av\n\n` +
+                        `We appreciate your willingness to provide feedback!`
+                }],
+            isError: true
+        };
+    }
+}
+/**
+ * Build Tally.so URL with pre-filled parameters
+ */
+async function buildTallyUrl(params, stats) {
+    const baseUrl = 'https://tally.so/r/mYB6av';
+    const urlParams = new URLSearchParams();
+    // Only auto-filled hidden fields remain
+    urlParams.set('tool_call_count', stats.totalToolCalls.toString());
+    // Calculate days using
+    const daysUsing = Math.floor((Date.now() - stats.firstUsed) / (1000 * 60 * 60 * 24));
+    urlParams.set('days_using', daysUsing.toString());
+    // Add platform info
+    urlParams.set('platform', os.platform());
+    // Add client_id from analytics config
+    try {
+        const clientId = await configManager.getValue('clientId') || 'unknown';
+        urlParams.set('client_id', clientId);
+    }
+    catch (error) {
+        // Fallback if config read fails
+        urlParams.set('client_id', 'unknown');
+    }
+    return `${baseUrl}?${urlParams.toString()}`;
+}
+/**
+ * Open URL in default browser (cross-platform)
+ */
+async function openUrlInBrowser(url) {
+    try {
+        const platform = os.platform();
+        let command;
+        switch (platform) {
+            case 'darwin': // macOS
+                command = `open "${url}"`;
+                break;
+            case 'win32': // Windows
+                command = `start "" "${url}"`;
+                break;
+            default: // Linux and others
+                command = `xdg-open "${url}"`;
+                break;
+        }
+        await execAsync(command);
+        return true;
+    }
+    catch (error) {
+        console.error('Failed to open browser:', error);
+        return false;
+    }
+}

package/dist/tools/filesystem.d.ts

@@ -36,6 +36,16 @@ export declare function readFileFromDisk(filePath: string, offset?: number, leng
  * @returns File content or file result with metadata
  */
 export declare function readFile(filePath: string, isUrl?: boolean, offset?: number, length?: number): Promise<FileResult>;
+/**
+ * Read file content without status messages for internal operations
+ * This function preserves exact file content including original line endings,
+ * which is essential for edit operations that need to maintain file formatting.
+ * @param filePath Path to the file
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
+ * @returns File content without status headers, with preserved line endings
+ */
+export declare function readFileInternal(filePath: string, offset?: number, length?: number): Promise<string>;
 export declare function writeFile(filePath: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
 export interface MultiFileResult {
     path: string;