@wonderwhy-er/desktop-commander 0.2.17 → 0.2.18-alpha.1

package/dist/tools/improved-process-tools.js

@@ -56,7 +56,7 @@ export async function startProcess(args) {
             }
         }
     }
-    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, shellUsed);
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms, shellUsed, parsed.data.verbose_timing || false);
     if (result.pid === -1) {
         return {
             content: [{ type: "text", text: result.output }],
@@ -75,13 +75,40 @@ export async function startProcess(args) {
     else if (result.isBlocked) {
         statusMessage = '\n⏳ Process is running. Use read_process_output to get more output.';
     }
+    // Add timing information if requested
+    let timingMessage = '';
+    if (result.timingInfo) {
+        timingMessage = formatTimingInfo(result.timingInfo);
+    }
     return {
         content: [{
                 type: "text",
-                text: `Process started with PID ${result.pid} (shell: ${shellUsed})\nInitial output:\n${result.output}${statusMessage}`
+                text: `Process started with PID ${result.pid} (shell: ${shellUsed})\nInitial output:\n${result.output}${statusMessage}${timingMessage}`
             }],
     };
 }
+function formatTimingInfo(timing) {
+    let msg = '\n\n📊 Timing Information:\n';
+    msg += `  Exit Reason: ${timing.exitReason}\n`;
+    msg += `  Total Duration: ${timing.totalDurationMs}ms\n`;
+    if (timing.timeToFirstOutputMs !== undefined) {
+        msg += `  Time to First Output: ${timing.timeToFirstOutputMs}ms\n`;
+    }
+    if (timing.firstOutputTime && timing.lastOutputTime) {
+        msg += `  Output Window: ${timing.lastOutputTime - timing.firstOutputTime}ms\n`;
+    }
+    if (timing.outputEvents && timing.outputEvents.length > 0) {
+        msg += `\n  Output Events (${timing.outputEvents.length} total):\n`;
+        timing.outputEvents.forEach((event, idx) => {
+            msg += `    [${idx + 1}] +${event.deltaMs}ms | ${event.source} | ${event.length}b`;
+            if (event.matchedPattern) {
+                msg += ` | 🎯 ${event.matchedPattern}`;
+            }
+            msg += `\n       "${event.snippet}"\n`;
+        });
+    }
+    return msg;
+}
 /**
  * Read output from a running process (renamed from read_output)
  * Includes early detection of process waiting for input
@@ -94,7 +121,7 @@ export async function readProcessOutput(args) {
             isError: true,
         };
     }
-    const { pid, timeout_ms = 5000 } = parsed.data;
+    const { pid, timeout_ms = 5000, verbose_timing = false } = parsed.data;
     const session = terminalManager.getSession(pid);
     if (!session) {
         // Check if this is a completed session
@@ -117,15 +144,35 @@ export async function readProcessOutput(args) {
     let timeoutReached = false;
     let earlyExit = false;
     let processState;
+    // Timing telemetry
+    const startTime = Date.now();
+    let firstOutputTime;
+    let lastOutputTime;
+    const outputEvents = [];
+    let exitReason = 'timeout';
     try {
         const outputPromise = new Promise((resolve) => {
             const initialOutput = terminalManager.getNewOutput(pid);
             if (initialOutput && initialOutput.length > 0) {
+                const now = Date.now();
+                if (!firstOutputTime)
+                    firstOutputTime = now;
+                lastOutputTime = now;
+                if (verbose_timing) {
+                    outputEvents.push({
+                        timestamp: now,
+                        deltaMs: now - startTime,
+                        source: 'initial_poll',
+                        length: initialOutput.length,
+                        snippet: initialOutput.slice(0, 50).replace(/\n/g, '\\n')
+                    });
+                }
                 // Immediate check on existing output
                 const state = analyzeProcessState(initialOutput, pid);
                 if (state.isWaitingForInput) {
                     earlyExit = true;
                     processState = state;
+                    exitReason = 'early_exit_periodic_check';
                 }
                 resolve(initialOutput);
                 return;
@@ -147,13 +194,28 @@ export async function readProcessOutput(args) {
                 resolved = true;
                 cleanup();
                 timeoutReached = isTimeout;
+                if (isTimeout)
+                    exitReason = 'timeout';
                 resolve(value);
             };
             // Monitor for new output with immediate detection
             const session = terminalManager.getSession(pid);
             if (session && session.process && session.process.stdout && session.process.stderr) {
-                const immediateDetector = (data) => {
+                const immediateDetector = (data, source) => {
                     const text = data.toString();
+                    const now = Date.now();
+                    if (!firstOutputTime)
+                        firstOutputTime = now;
+                    lastOutputTime = now;
+                    if (verbose_timing) {
+                        outputEvents.push({
+                            timestamp: now,
+                            deltaMs: now - startTime,
+                            source,
+                            length: text.length,
+                            snippet: text.slice(0, 50).replace(/\n/g, '\\n')
+                        });
+                    }
                     // Immediate check for obvious prompts
                     if (quickPromptPatterns.test(text)) {
                         const newOutput = terminalManager.getNewOutput(pid) || text;
@@ -161,21 +223,27 @@ export async function readProcessOutput(args) {
                         if (state.isWaitingForInput) {
                             earlyExit = true;
                             processState = state;
+                            exitReason = 'early_exit_quick_pattern';
+                            if (verbose_timing && outputEvents.length > 0) {
+                                outputEvents[outputEvents.length - 1].matchedPattern = 'quick_pattern';
+                            }
                             resolveOnce(newOutput);
                             return;
                         }
                     }
                 };
-                session.process.stdout.on('data', immediateDetector);
-                session.process.stderr.on('data', immediateDetector);
+                const stdoutDetector = (data) => immediateDetector(data, 'stdout');
+                const stderrDetector = (data) => immediateDetector(data, 'stderr');
+                session.process.stdout.on('data', stdoutDetector);
+                session.process.stderr.on('data', stderrDetector);
                 // Cleanup immediate detectors when done
                 const originalResolveOnce = resolveOnce;
                 const cleanupDetectors = () => {
                     if (session.process.stdout) {
-                        session.process.stdout.removeListener('data', immediateDetector);
+                        session.process.stdout.off('data', stdoutDetector);
                     }
                     if (session.process.stderr) {
-                        session.process.stderr.removeListener('data', immediateDetector);
+                        session.process.stderr.off('data', stderrDetector);
                     }
                 };
                 // Override resolveOnce to include cleanup
@@ -189,12 +257,29 @@ export async function readProcessOutput(args) {
             interval = setInterval(() => {
                 const newOutput = terminalManager.getNewOutput(pid);
                 if (newOutput && newOutput.length > 0) {
+                    const now = Date.now();
+                    if (!firstOutputTime)
+                        firstOutputTime = now;
+                    lastOutputTime = now;
+                    if (verbose_timing) {
+                        outputEvents.push({
+                            timestamp: now,
+                            deltaMs: now - startTime,
+                            source: 'periodic_poll',
+                            length: newOutput.length,
+                            snippet: newOutput.slice(0, 50).replace(/\n/g, '\\n')
+                        });
+                    }
                     const currentOutput = output + newOutput;
                     const state = analyzeProcessState(currentOutput, pid);
                     // Early exit if process is clearly waiting for input
                     if (state.isWaitingForInput) {
                         earlyExit = true;
                         processState = state;
+                        exitReason = 'early_exit_periodic_check';
+                        if (verbose_timing && outputEvents.length > 0) {
+                            outputEvents[outputEvents.length - 1].matchedPattern = 'periodic_check';
+                        }
                         resolveOnce(newOutput);
                         return;
                     }
@@ -205,9 +290,10 @@ export async function readProcessOutput(args) {
                     }
                     // Process finished
                     processState = state;
+                    exitReason = 'process_finished';
                     resolveOnce(newOutput);
                 }
-            }, 200); // Check every 200ms
+            }, 50); // Check every 50ms for faster response
             timeout = setTimeout(() => {
                 const finalOutput = terminalManager.getNewOutput(pid) || "";
                 resolveOnce(finalOutput, true);
@@ -237,11 +323,27 @@ export async function readProcessOutput(args) {
     else if (timeoutReached) {
         statusMessage = '\n⏱️ Timeout reached - process may still be running';
     }
+    // Add timing information if requested
+    let timingMessage = '';
+    if (verbose_timing) {
+        const endTime = Date.now();
+        const timingInfo = {
+            startTime,
+            endTime,
+            totalDurationMs: endTime - startTime,
+            exitReason,
+            firstOutputTime,
+            lastOutputTime,
+            timeToFirstOutputMs: firstOutputTime ? firstOutputTime - startTime : undefined,
+            outputEvents: outputEvents.length > 0 ? outputEvents : undefined
+        };
+        timingMessage = formatTimingInfo(timingInfo);
+    }
     const responseText = output || 'No new output available';
     return {
         content: [{
                 type: "text",
-                text: `${responseText}${statusMessage}`
+                text: `${responseText}${statusMessage}${timingMessage}`
             }],
     };
 }
@@ -260,7 +362,13 @@ export async function interactWithProcess(args) {
             isError: true,
         };
     }
-    const { pid, input, timeout_ms = 8000, wait_for_prompt = true } = parsed.data;
+    const { pid, input, timeout_ms = 8000, wait_for_prompt = true, verbose_timing = false } = parsed.data;
+    // Timing telemetry
+    const startTime = Date.now();
+    let firstOutputTime;
+    let lastOutputTime;
+    const outputEvents = [];
+    let exitReason = 'timeout';
     try {
         capture('server_interact_with_process', {
             pid: pid,
@@ -275,10 +383,26 @@ export async function interactWithProcess(args) {
         }
         // If not waiting for response, return immediately
         if (!wait_for_prompt) {
+            exitReason = 'no_wait';
+            let timingMessage = '';
+            if (verbose_timing) {
+                const endTime = Date.now();
+                const timingInfo = {
+                    startTime,
+                    endTime,
+                    totalDurationMs: endTime - startTime,
+                    exitReason,
+                    firstOutputTime,
+                    lastOutputTime,
+                    timeToFirstOutputMs: undefined,
+                    outputEvents: undefined
+                };
+                timingMessage = formatTimingInfo(timingInfo);
+            }
             return {
                 content: [{
                         type: "text",
-                        text: `✅ Input sent to process ${pid}. Use read_process_output to get the response.`
+                        text: `✅ Input sent to process ${pid}. Use read_process_output to get the response.${timingMessage}`
                     }],
             };
         }
@@ -292,7 +416,8 @@ export async function interactWithProcess(args) {
             return new Promise((resolve) => {
                 let resolved = false;
                 let attempts = 0;
-                const maxAttempts = Math.ceil(timeout_ms / 200);
+                const pollIntervalMs = 50; // Poll every 50ms for faster response
+                const maxAttempts = Math.ceil(timeout_ms / pollIntervalMs);
                 let interval = null;
                 let resolveOnce = () => {
                     if (resolved)
@@ -302,74 +427,51 @@ export async function interactWithProcess(args) {
                         clearInterval(interval);
                     resolve();
                 };
-                // Set up immediate detection on the process streams
-                const session = terminalManager.getSession(pid);
-                if (session && session.process && session.process.stdout && session.process.stderr) {
-                    const immediateDetector = (data) => {
-                        const text = data.toString();
-                        // Immediate check for obvious prompts
-                        if (quickPromptPatterns.test(text)) {
-                            // Get the latest output and analyze
-                            setTimeout(() => {
-                                const newOutput = terminalManager.getNewOutput(pid);
-                                if (newOutput) {
-                                    output += newOutput;
-                                    const state = analyzeProcessState(output, pid);
-                                    if (state.isWaitingForInput) {
-                                        processState = state;
-                                        earlyExit = true;
-                                        resolveOnce();
-                                    }
-                                }
-                            }, 50); // Small delay to ensure output is captured
-                        }
-                    };
-                    session.process.stdout.on('data', immediateDetector);
-                    session.process.stderr.on('data', immediateDetector);
-                    // Cleanup when done
-                    const cleanupDetectors = () => {
-                        if (session.process.stdout) {
-                            session.process.stdout.removeListener('data', immediateDetector);
-                        }
-                        if (session.process.stderr) {
-                            session.process.stderr.removeListener('data', immediateDetector);
-                        }
-                    };
-                    // Override resolveOnce to include cleanup
-                    const originalResolveOnce = resolveOnce;
-                    const resolveOnceWithCleanup = () => {
-                        cleanupDetectors();
-                        originalResolveOnce();
-                    };
-                    // Replace the local resolveOnce reference
-                    resolveOnce = resolveOnceWithCleanup;
-                }
-                // Periodic check as fallback
+                // Fast-polling check - check every 50ms for quick responses
                 interval = setInterval(() => {
                     if (resolved)
                         return;
                     const newOutput = terminalManager.getNewOutput(pid);
                     if (newOutput && newOutput.length > 0) {
+                        const now = Date.now();
+                        if (!firstOutputTime)
+                            firstOutputTime = now;
+                        lastOutputTime = now;
+                        if (verbose_timing) {
+                            outputEvents.push({
+                                timestamp: now,
+                                deltaMs: now - startTime,
+                                source: 'periodic_poll',
+                                length: newOutput.length,
+                                snippet: newOutput.slice(0, 50).replace(/\n/g, '\\n')
+                            });
+                        }
                         output += newOutput;
                         // Analyze current state
                         processState = analyzeProcessState(output, pid);
                         // Exit early if we detect the process is waiting for input
                         if (processState.isWaitingForInput) {
                             earlyExit = true;
+                            exitReason = 'early_exit_periodic_check';
+                            if (verbose_timing && outputEvents.length > 0) {
+                                outputEvents[outputEvents.length - 1].matchedPattern = 'periodic_check';
+                            }
                             resolveOnce();
                             return;
                         }
                         // Also exit if process finished
                         if (processState.isFinished) {
+                            exitReason = 'process_finished';
                             resolveOnce();
                             return;
                         }
                     }
                     attempts++;
                     if (attempts >= maxAttempts) {
+                        exitReason = 'timeout';
                         resolveOnce();
                     }
-                }, 200);
+                }, pollIntervalMs);
             });
         };
         await waitForResponse();
@@ -390,11 +492,27 @@ export async function interactWithProcess(args) {
         else if (timeoutReached) {
             statusMessage = '\n⏱️ Response may be incomplete (timeout reached)';
         }
+        // Add timing information if requested
+        let timingMessage = '';
+        if (verbose_timing) {
+            const endTime = Date.now();
+            const timingInfo = {
+                startTime,
+                endTime,
+                totalDurationMs: endTime - startTime,
+                exitReason,
+                firstOutputTime,
+                lastOutputTime,
+                timeToFirstOutputMs: firstOutputTime ? firstOutputTime - startTime : undefined,
+                outputEvents: outputEvents.length > 0 ? outputEvents : undefined
+            };
+            timingMessage = formatTimingInfo(timingInfo);
+        }
         if (cleanOutput.trim().length === 0 && !timeoutReached) {
             return {
                 content: [{
                         type: "text",
-                        text: `✅ Input executed in process ${pid}.\n📭 (No output produced)${statusMessage}`
+                        text: `✅ Input executed in process ${pid}.\n📭 (No output produced)${statusMessage}${timingMessage}`
                     }],
             };
         }
@@ -409,6 +527,9 @@ export async function interactWithProcess(args) {
         if (statusMessage) {
             responseText += `\n\n${statusMessage}`;
         }
+        if (timingMessage) {
+            responseText += timingMessage;
+        }
         return {
             content: [{
                     type: "text",

package/dist/tools/schemas.d.ts

@@ -15,24 +15,30 @@ export declare const StartProcessArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodNumber;
     shell: z.ZodOptional<z.ZodString>;
+    verbose_timing: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     command: string;
     timeout_ms: number;
     shell?: string | undefined;
+    verbose_timing?: boolean | undefined;
 }, {
     command: string;
     timeout_ms: number;
     shell?: string | undefined;
+    verbose_timing?: boolean | undefined;
 }>;
 export declare const ReadProcessOutputArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
+    verbose_timing: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     pid: number;
     timeout_ms?: number | undefined;
+    verbose_timing?: boolean | undefined;
 }, {
     pid: number;
     timeout_ms?: number | undefined;
+    verbose_timing?: boolean | undefined;
 }>;
 export declare const ForceTerminateArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
@@ -140,15 +146,18 @@ export declare const InteractWithProcessArgsSchema: z.ZodObject<{
     input: z.ZodString;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
     wait_for_prompt: z.ZodOptional<z.ZodBoolean>;
+    verbose_timing: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     pid: number;
     input: string;
     timeout_ms?: number | undefined;
+    verbose_timing?: boolean | undefined;
     wait_for_prompt?: boolean | undefined;
 }, {
     pid: number;
     input: string;
     timeout_ms?: number | undefined;
+    verbose_timing?: boolean | undefined;
     wait_for_prompt?: boolean | undefined;
 }>;
 export declare const GetUsageStatsArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/dist/tools/schemas.js

@@ -18,10 +18,12 @@ export const StartProcessArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number(),
     shell: z.string().optional(),
+    verbose_timing: z.boolean().optional(),
 });
 export const ReadProcessOutputArgsSchema = z.object({
     pid: z.number(),
     timeout_ms: z.number().optional(),
+    verbose_timing: z.boolean().optional(),
 });
 export const ForceTerminateArgsSchema = z.object({
     pid: z.number(),
@@ -72,6 +74,7 @@ export const InteractWithProcessArgsSchema = z.object({
     input: z.string(),
     timeout_ms: z.number().optional(),
     wait_for_prompt: z.boolean().optional(),
+    verbose_timing: z.boolean().optional(),
 });
 // Usage stats schema
 export const GetUsageStatsArgsSchema = z.object({});

package/dist/types.d.ts

@@ -21,6 +21,25 @@ export interface CommandExecutionResult {
     pid: number;
     output: string;
     isBlocked: boolean;
+    timingInfo?: TimingInfo;
+}
+export interface TimingInfo {
+    startTime: number;
+    endTime: number;
+    totalDurationMs: number;
+    exitReason: 'early_exit_quick_pattern' | 'early_exit_periodic_check' | 'process_exit' | 'timeout';
+    firstOutputTime?: number;
+    lastOutputTime?: number;
+    timeToFirstOutputMs?: number;
+    outputEvents?: OutputEvent[];
+}
+export interface OutputEvent {
+    timestamp: number;
+    deltaMs: number;
+    source: 'stdout' | 'stderr';
+    length: number;
+    snippet: string;
+    matchedPattern?: string;
 }
 export interface ActiveSession {
     pid: number;

package/dist/utils/feature-flags.d.ts

@@ -0,0 +1,43 @@
+declare class FeatureFlagManager {
+    private flags;
+    private lastFetch;
+    private cachePath;
+    private cacheMaxAge;
+    private flagUrl;
+    private refreshInterval;
+    constructor();
+    /**
+     * Initialize - load from cache and start background refresh
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get a flag value
+     */
+    get(flagName: string, defaultValue?: any): any;
+    /**
+     * Get all flags for debugging
+     */
+    getAll(): Record<string, any>;
+    /**
+     * Manually refresh flags immediately (for testing)
+     */
+    refresh(): Promise<boolean>;
+    /**
+     * Load flags from local cache
+     */
+    private loadFromCache;
+    /**
+     * Fetch flags from remote URL
+     */
+    private fetchFlags;
+    /**
+     * Save flags to local cache
+     */
+    private saveToCache;
+    /**
+     * Cleanup on shutdown
+     */
+    destroy(): void;
+}
+export declare const featureFlagManager: FeatureFlagManager;
+export {};