@wonderwhy-er/desktop-commander 0.1.18 → 0.1.19

package/dist/terminal-manager.d.ts

@@ -1,9 +1,19 @@
 import { CommandExecutionResult, ActiveSession } from './types.js';
+interface CompletedSession {
+    pid: number;
+    output: string;
+    exitCode: number | null;
+    startTime: Date;
+    endTime: Date;
+}
 export declare class TerminalManager {
     private sessions;
+    private completedSessions;
     executeCommand(command: string, timeoutMs?: number): Promise<CommandExecutionResult>;
     getNewOutput(pid: number): string | null;
     forceTerminate(pid: number): boolean;
     listActiveSessions(): ActiveSession[];
+    listCompletedSessions(): CompletedSession[];
 }
 export declare const terminalManager: TerminalManager;
+export {};

package/dist/terminal-manager.js

@@ -3,6 +3,7 @@ import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 export class TerminalManager {
     constructor() {
         this.sessions = new Map();
+        this.completedSessions = new Map();
     }
     async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT) {
         const process = spawn(command, [], { shell: true });
@@ -38,8 +39,21 @@ export class TerminalManager {
                     isBlocked: true
                 });
             }, timeoutMs);
-            process.on('exit', () => {
+            process.on('exit', (code) => {
                 if (process.pid) {
+                    // Store completed session before removing active session
+                    this.completedSessions.set(process.pid, {
+                        pid: process.pid,
+                        output: output + session.lastOutput, // Combine all output
+                        exitCode: code,
+                        startTime: session.startTime,
+                        endTime: new Date()
+                    });
+                    // Keep only last 100 completed sessions
+                    if (this.completedSessions.size > 100) {
+                        const oldestKey = Array.from(this.completedSessions.keys())[0];
+                        this.completedSessions.delete(oldestKey);
+                    }
                     this.sessions.delete(process.pid);
                 }
                 resolve({
@@ -51,13 +65,21 @@ export class TerminalManager {
         });
     }
     getNewOutput(pid) {
+        // First check active sessions
         const session = this.sessions.get(pid);
-        if (!session) {
-            return null;
+        if (session) {
+            const output = session.lastOutput;
+            session.lastOutput = '';
+            return output;
+        }
+        // Then check completed sessions
+        const completedSession = this.completedSessions.get(pid);
+        if (completedSession) {
+            // Format completion message with exit code and runtime
+            const runtime = (completedSession.endTime.getTime() - completedSession.startTime.getTime()) / 1000;
+            return `Process completed with exit code ${completedSession.exitCode}\nRuntime: ${runtime}s\nFinal output:\n${completedSession.output}`;
         }
-        const output = session.lastOutput;
-        session.lastOutput = '';
-        return output;
+        return null;
     }
     forceTerminate(pid) {
         const session = this.sessions.get(pid);
@@ -86,5 +108,8 @@ export class TerminalManager {
             runtime: now.getTime() - session.startTime.getTime()
         }));
     }
+    listCompletedSessions() {
+        return Array.from(this.completedSessions.values());
+    }
 }
 export const terminalManager = new TerminalManager();

package/dist/tools/progress.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const LongRunningTaskSchema: z.ZodObject<{
+    total_steps: z.ZodDefault<z.ZodNumber>;
+    step_duration: z.ZodDefault<z.ZodNumber>;
+    should_fail: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    total_steps: number;
+    step_duration: number;
+    should_fail: boolean;
+}, {
+    total_steps?: number | undefined;
+    step_duration?: number | undefined;
+    should_fail?: boolean | undefined;
+}>;
+export declare function executeLongRunning(args: unknown, server: any, progressToken?: string): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/progress.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+export const LongRunningTaskSchema = z.object({
+    total_steps: z.number().default(5).describe("Total number of steps to execute"),
+    step_duration: z.number().default(1000).describe("Duration of each step in milliseconds"),
+    should_fail: z.boolean().default(false).describe("Whether the task should fail midway through"),
+});
+export async function executeLongRunning(args, server, progressToken) {
+    const parsed = LongRunningTaskSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for long_running_task: ${parsed.error}`);
+    }
+    const { total_steps, step_duration, should_fail } = parsed.data;
+    try {
+        for (let step = 1; step <= total_steps; step++) {
+            // Simulate work
+            await new Promise(resolve => setTimeout(resolve, step_duration));
+            // Send progress notification if we have a token
+            if (progressToken) {
+                await server.notification({
+                    method: "notifications/progress",
+                    params: {
+                        progress: step,
+                        total: total_steps,
+                        progressToken,
+                        detail: `Completed step ${step} of ${total_steps}${should_fail && step === Math.floor(total_steps / 2)
+                            ? ' (about to fail)'
+                            : ''}`
+                    }
+                });
+            }
+            // If should_fail is true, fail halfway through
+            if (should_fail && step === Math.floor(total_steps / 2)) {
+                throw new Error("Task failed halfway through as requested");
+            }
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Long running task completed successfully after ${total_steps} steps`
+                }]
+        };
+    }
+    catch (error) {
+        // Send error notification if we have a token
+        if (progressToken) {
+            await server.notification({
+                method: "notifications/progress",
+                params: {
+                    progress: Math.floor(total_steps / 2),
+                    total: total_steps,
+                    progressToken,
+                    detail: error instanceof Error ? error.message : 'Unknown error',
+                    error: true
+                }
+            });
+        }
+        throw error;
+    }
+}

package/dist/types.d.ts

@@ -22,3 +22,10 @@ export interface ActiveSession {
     isBlocked: boolean;
     runtime: number;
 }
+export interface CompletedSession {
+    pid: number;
+    output: string;
+    exitCode: number | null;
+    startTime: Date;
+    endTime: Date;
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.18";
+export declare const VERSION = "0.1.19";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.18';
+export const VERSION = '0.1.19';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",