feat: read output timeout

Author: serg33v

src/server.ts

@@ -335,6 +335,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     name: "read_output",
                     description: `
                         Read new output from a running terminal session.
+                        Set timeout_ms for long running commands.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadOutputArgsSchema),

src/terminal-manager.ts

@@ -126,6 +126,15 @@ export class TerminalManager {
     return null;
   }
 
+    /**
+   * Get a session by PID
+   * @param pid Process ID
+   * @returns The session or undefined if not found
+   */
+  getSession(pid: number): TerminalSession | undefined {
+    return this.sessions.get(pid);
+  }
+
   forceTerminate(pid: number): boolean {
     const session = this.sessions.get(pid);
     if (!session) {

src/tools/execute.ts

@@ -62,21 +62,66 @@ export async function executeCommand(args: unknown): Promise<ServerResult> {
 }
 
 export async function readOutput(args: unknown): Promise<ServerResult> {
-  const parsed = ReadOutputArgsSchema.safeParse(args);
-  if (!parsed.success) {
-    return {
-      content: [{ type: "text", text: `Error: Invalid arguments for read_output: ${parsed.error}` }],
-      isError: true,
-    };
-  }
+    const parsed = ReadOutputArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for read_output: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+
+    const { pid, timeout_ms = 5000 } = parsed.data;
+
+    // Check if the process exists
+    const session = terminalManager.getSession(pid);
+    if (!session) {
+        return {
+            content: [{ type: "text", text: `No session found for PID ${pid}` }],
+            isError: true,
+        };
+    }
+    // Wait for output with timeout
+    let output = "";
+    let timeoutReached = false;
+    try {
+        // Create a promise that resolves when new output is available or when timeout is reached
+        const outputPromise:Promise<string> = new Promise<string>((resolve) => {
+            // Check for initial output
+            const initialOutput = terminalManager.getNewOutput(pid);
+            if (initialOutput && initialOutput.length > 0) {
+                resolve(initialOutput);
+                return;
+            }
+
+            // Setup an interval to poll for output
+            const interval = setInterval(() => {
+                const newOutput = terminalManager.getNewOutput(pid);
+                if (newOutput && newOutput.length > 0) {
+                    clearInterval(interval);
+                    resolve(newOutput);
+                }
+            }, 300); // Check every 300ms
+
+        // Set a timeout to stop waiting
+            setTimeout(() => {
+                clearInterval(interval);
+                timeoutReached = true;
+                resolve(terminalManager.getNewOutput(pid) || "");
+            }, timeout_ms);
+        });
+
+        output = await outputPromise;
+    } catch (error) {
+        return {
+            content: [{ type: "text", text: `Error reading output: ${error}` }],
+            isError: true,
+        };
+    }
 
-  const output = terminalManager.getNewOutput(parsed.data.pid);
   return {
     content: [{
       type: "text",
-      text: output === null
-        ? `No session found for PID ${parsed.data.pid}`
-        : output || 'No new output available'
+      text: output || 'No new output available' + (timeoutReached ? ' (timeout reached)' : '')
     }],
   };
 }

src/tools/schemas.ts

@@ -22,6 +22,7 @@ export const ExecuteCommandArgsSchema = z.object({
 
 export const ReadOutputArgsSchema = z.object({
   pid: z.number(),
+  timeout_ms: z.number().optional(),
 });
 
 export const ForceTerminateArgsSchema = z.object({