@wonderwhy-er/desktop-commander 0.2.23 → 0.2.25

package/dist/terminal-manager.js

@@ -156,7 +156,8 @@ export class TerminalManager {
         const session = {
             pid: childProcess.pid,
             process: childProcess,
-            lastOutput: '',
+            outputLines: [], // Line-based buffer
+            lastReadIndex: 0, // Track where "new" output starts
             isBlocked: false,
             startTime: new Date()
         };
@@ -201,7 +202,8 @@ export class TerminalManager {
                     firstOutputTime = now;
                 lastOutputTime = now;
                 output += text;
-                session.lastOutput += text;
+                // Append to line-based buffer
+                this.appendToLineBuffer(session, text);
                 // Record output event if collecting timing
                 if (collectTiming) {
                     outputEvents.push({
@@ -233,7 +235,8 @@ export class TerminalManager {
                     firstOutputTime = now;
                 lastOutputTime = now;
                 output += text;
-                session.lastOutput += text;
+                // Append to line-based buffer
+                this.appendToLineBuffer(session, text);
                 // Record output event if collecting timing
                 if (collectTiming) {
                     outputEvents.push({
@@ -275,7 +278,7 @@ export class TerminalManager {
                     // Store completed session before removing active session
                     this.completedSessions.set(childProcess.pid, {
                         pid: childProcess.pid,
-                        output: output, // Use only the main output variable
+                        outputLines: [...session.outputLines], // Copy line buffer
                         exitCode: code,
                         startTime: session.startTime,
                         endTime: new Date()
@@ -296,26 +299,179 @@ export class TerminalManager {
             });
         });
     }
-    getNewOutput(pid) {
+    /**
+     * Append text to a session's line buffer
+     * Handles partial lines and newline splitting
+     */
+    appendToLineBuffer(session, text) {
+        if (!text)
+            return;
+        // Split text into lines, keeping track of whether text ends with newline
+        const lines = text.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const isLastFragment = i === lines.length - 1;
+            const endsWithNewline = text.endsWith('\n');
+            if (session.outputLines.length === 0) {
+                // First line ever
+                session.outputLines.push(line);
+            }
+            else if (i === 0) {
+                // First fragment - append to last line (might be partial)
+                session.outputLines[session.outputLines.length - 1] += line;
+            }
+            else {
+                // Subsequent lines - add as new lines
+                session.outputLines.push(line);
+            }
+        }
+    }
+    /**
+     * Read process output with pagination (like file reading)
+     * @param pid Process ID
+     * @param offset Line offset: 0=from lastReadIndex, positive=absolute, negative=tail
+     * @param length Max lines to return
+     * @param updateReadIndex Whether to update lastReadIndex (default: true for offset=0)
+     */
+    readOutputPaginated(pid, offset = 0, length = 1000) {
         // First check active sessions
         const session = this.sessions.get(pid);
         if (session) {
-            const output = session.lastOutput;
-            session.lastOutput = '';
-            return output;
+            return this.readFromLineBuffer(session.outputLines, offset, length, session.lastReadIndex, (newIndex) => { session.lastReadIndex = newIndex; }, false, undefined);
         }
         // Then check completed sessions
         const completedSession = this.completedSessions.get(pid);
         if (completedSession) {
-            // Format with output first, then completion info
-            const runtime = (completedSession.endTime.getTime() - completedSession.startTime.getTime()) / 1000;
-            const output = completedSession.output.trim();
+            const runtimeMs = completedSession.endTime.getTime() - completedSession.startTime.getTime();
+            return this.readFromLineBuffer(completedSession.outputLines, offset, length, 0, // Completed sessions don't track read position
+            () => { }, // No-op for completed sessions
+            true, completedSession.exitCode, runtimeMs);
+        }
+        return null;
+    }
+    /**
+     * Internal helper to read from a line buffer with offset/length
+     */
+    readFromLineBuffer(lines, offset, length, lastReadIndex, updateLastRead, isComplete, exitCode, runtimeMs) {
+        const totalLines = lines.length;
+        let startIndex;
+        let linesToRead;
+        if (offset < 0) {
+            // Negative offset = start position from end, then read 'length' lines forward
+            // e.g., offset=-50, length=10 means: start 50 lines from end, read 10 lines
+            const fromEnd = Math.abs(offset);
+            startIndex = Math.max(0, totalLines - fromEnd);
+            linesToRead = lines.slice(startIndex, startIndex + length);
+            // Don't update lastReadIndex for tail reads
+        }
+        else if (offset === 0) {
+            // offset=0 means "from where I last read" (like getNewOutput)
+            startIndex = lastReadIndex;
+            linesToRead = lines.slice(startIndex, startIndex + length);
+            // Update lastReadIndex for "new output" behavior
+            updateLastRead(Math.min(startIndex + linesToRead.length, totalLines));
+        }
+        else {
+            // Positive offset = absolute position
+            startIndex = offset;
+            linesToRead = lines.slice(startIndex, startIndex + length);
+            // Don't update lastReadIndex for absolute position reads
+        }
+        const readCount = linesToRead.length;
+        const endIndex = startIndex + readCount;
+        const remaining = Math.max(0, totalLines - endIndex);
+        return {
+            lines: linesToRead,
+            totalLines,
+            readFrom: startIndex,
+            readCount,
+            remaining,
+            isComplete,
+            exitCode,
+            runtimeMs
+        };
+    }
+    /**
+     * Get total line count for a process
+     */
+    getOutputLineCount(pid) {
+        const session = this.sessions.get(pid);
+        if (session) {
+            return session.outputLines.length;
+        }
+        const completedSession = this.completedSessions.get(pid);
+        if (completedSession) {
+            return completedSession.outputLines.length;
+        }
+        return null;
+    }
+    /**
+     * Legacy method for backward compatibility
+     * Returns all new output since last read
+     * @param maxLines Maximum lines to return (default: 1000 for context protection)
+     * @deprecated Use readOutputPaginated instead
+     */
+    getNewOutput(pid, maxLines = 1000) {
+        const result = this.readOutputPaginated(pid, 0, maxLines);
+        if (!result)
+            return null;
+        const output = result.lines.join('\n').trim();
+        // For completed sessions, append completion info with runtime
+        if (result.isComplete) {
+            const runtimeStr = result.runtimeMs !== undefined
+                ? `\nRuntime: ${(result.runtimeMs / 1000).toFixed(2)}s`
+                : '';
             if (output) {
-                return `${output}\n\nProcess completed with exit code ${completedSession.exitCode}\nRuntime: ${runtime}s`;
+                return `${output}\n\nProcess completed with exit code ${result.exitCode}${runtimeStr}`;
             }
             else {
-                return `Process completed with exit code ${completedSession.exitCode}\nRuntime: ${runtime}s\n(No output produced)`;
+                return `Process completed with exit code ${result.exitCode}${runtimeStr}\n(No output produced)`;
+            }
+        }
+        // Add truncation warning if there's more output
+        if (result.remaining > 0) {
+            return `${output}\n\n[Output truncated: ${result.remaining} more lines available. Use read_process_output with offset/length for full output.]`;
+        }
+        return output || null;
+    }
+    /**
+     * Capture a snapshot of current output state for interaction tracking.
+     * Used by interactWithProcess to know what output existed before sending input.
+     */
+    captureOutputSnapshot(pid) {
+        const session = this.sessions.get(pid);
+        if (session) {
+            const fullOutput = session.outputLines.join('\n');
+            return {
+                totalChars: fullOutput.length,
+                lineCount: session.outputLines.length
+            };
+        }
+        return null;
+    }
+    /**
+     * Get output that appeared since a snapshot was taken.
+     * This handles the case where output is appended to the last line (REPL prompts).
+     * Also checks completed sessions in case process finished between snapshot and poll.
+     */
+    getOutputSinceSnapshot(pid, snapshot) {
+        // Check active session first
+        const session = this.sessions.get(pid);
+        if (session) {
+            const fullOutput = session.outputLines.join('\n');
+            if (fullOutput.length <= snapshot.totalChars) {
+                return ''; // No new output
+            }
+            return fullOutput.substring(snapshot.totalChars);
+        }
+        // Fallback to completed sessions - process may have finished between snapshot and poll
+        const completedSession = this.completedSessions.get(pid);
+        if (completedSession) {
+            const fullOutput = completedSession.outputLines.join('\n');
+            if (fullOutput.length <= snapshot.totalChars) {
+                return ''; // No new output
             }
+            return fullOutput.substring(snapshot.totalChars);
         }
         return null;
     }

package/dist/tools/edit.d.ts

@@ -1,3 +1,19 @@
+/**
+ * Text file editing via search/replace with fuzzy matching support.
+ *
+ * TECHNICAL DEBT / ARCHITECTURAL NOTE:
+ * This file contains text editing logic that should ideally live in TextFileHandler.editRange()
+ * to be consistent with how Excel editing works (ExcelFileHandler.editRange()).
+ *
+ * Current inconsistency:
+ * - Excel: edit_block → ExcelFileHandler.editRange() ✓ uses file handler
+ * - Text:  edit_block → performSearchReplace() here → bypasses TextFileHandler
+ *
+ * Future refactor should:
+ * 1. Move performSearchReplace() + fuzzy logic into TextFileHandler.editRange()
+ * 2. Make this file a thin dispatch layer that routes to appropriate FileHandler
+ * 3. Unify the editRange() signature to handle both text search/replace and structured edits
+ */
 import { ServerResult } from '../types.js';
 interface SearchReplace {
     search: string;
@@ -5,10 +21,18 @@ interface SearchReplace {
 }
 export declare function performSearchReplace(filePath: string, block: SearchReplace, expectedReplacements?: number): Promise<ServerResult>;
 /**
- * Handle edit_block command with enhanced functionality
- * - Supports multiple replacements
- * - Validates expected replacements count
- * - Provides detailed error messages
+ * Handle edit_block command
+ *
+ * 1. Text files: String replacement (old_string/new_string)
+ *    - Uses fuzzy matching for resilience
+ *    - Handles expected_replacements parameter
+ *
+ * 2. Structured files (Excel): Range rewrite (range + content)
+ *    - Bulk updates to cell ranges (e.g., "Sheet1!A1:C10")
+ *    - Whole sheet replacement (e.g., "Sheet1")
+ *    - More powerful and simpler than surgical location-based edits
+ *    - Supports chunking for large datasets (e.g., 1000 rows at a time)
+
  */
 export declare function handleEditBlock(args: unknown): Promise<ServerResult>;
 export {};

package/dist/tools/edit.js

@@ -1,3 +1,19 @@
+/**
+ * Text file editing via search/replace with fuzzy matching support.
+ *
+ * TECHNICAL DEBT / ARCHITECTURAL NOTE:
+ * This file contains text editing logic that should ideally live in TextFileHandler.editRange()
+ * to be consistent with how Excel editing works (ExcelFileHandler.editRange()).
+ *
+ * Current inconsistency:
+ * - Excel: edit_block → ExcelFileHandler.editRange() ✓ uses file handler
+ * - Text:  edit_block → performSearchReplace() here → bypasses TextFileHandler
+ *
+ * Future refactor should:
+ * 1. Move performSearchReplace() + fuzzy logic into TextFileHandler.editRange()
+ * 2. Make this file a thin dispatch layer that routes to appropriate FileHandler
+ * 3. Unify the editRange() signature to handle both text search/replace and structured edits
+ */
 import { writeFile, readFileInternal, validatePath } from './filesystem.js';
 import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
@@ -273,13 +289,80 @@ function highlightDifferences(expected, actual) {
     return `${commonPrefix}{-${expectedDiff}-}{+${actualDiff}+}${commonSuffix}`;
 }
 /**
- * Handle edit_block command with enhanced functionality
- * - Supports multiple replacements
- * - Validates expected replacements count
- * - Provides detailed error messages
+ * Handle edit_block command
+ *
+ * 1. Text files: String replacement (old_string/new_string)
+ *    - Uses fuzzy matching for resilience
+ *    - Handles expected_replacements parameter
+ *
+ * 2. Structured files (Excel): Range rewrite (range + content)
+ *    - Bulk updates to cell ranges (e.g., "Sheet1!A1:C10")
+ *    - Whole sheet replacement (e.g., "Sheet1")
+ *    - More powerful and simpler than surgical location-based edits
+ *    - Supports chunking for large datasets (e.g., 1000 rows at a time)
+
  */
 export async function handleEditBlock(args) {
     const parsed = EditBlockArgsSchema.parse(args);
+    // Structured files: Range rewrite
+    if (parsed.range !== undefined && parsed.content !== undefined) {
+        try {
+            // Validate path before any filesystem operations
+            const validatedPath = await validatePath(parsed.file_path);
+            const { getFileHandler } = await import('../utils/files/factory.js');
+            const handler = await getFileHandler(validatedPath);
+            // Parse content if it's a JSON string (AI often sends arrays as JSON strings)
+            let content = parsed.content;
+            if (typeof content === 'string') {
+                try {
+                    content = JSON.parse(content);
+                }
+                catch {
+                    // Leave as-is if not valid JSON - let handler decide
+                }
+            }
+            // Check if handler supports range editing
+            if ('editRange' in handler && typeof handler.editRange === 'function') {
+                await handler.editRange(validatedPath, parsed.range, content, parsed.options);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Successfully updated range ${parsed.range} in ${parsed.file_path}`
+                        }],
+                };
+            }
+            else {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Range-based editing not supported for ${parsed.file_path}`
+                        }],
+                    isError: true
+                };
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${errorMessage}`
+                    }],
+                isError: true
+            };
+        }
+    }
+    // Text files: String replacement
+    // Validate required parameters for text replacement
+    if (parsed.old_string === undefined || parsed.new_string === undefined) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Error: Text replacement requires both old_string and new_string parameters`
+                }],
+            isError: true
+        };
+    }
     const searchReplace = {
         search: parsed.old_string,
         replace: parsed.new_string

package/dist/tools/filesystem.d.ts

@@ -1,3 +1,5 @@
+import type { ReadOptions, FileResult, PdfPageItem } from '../utils/files/base.js';
+import { PdfOperations, PdfMetadata } from './pdf/index.js';
 /**
  * Validates a path to ensure it can be accessed or created.
  * For existing paths, returns the real path (resolving symlinks).
@@ -8,11 +10,12 @@
  * @throws Error if the path or its parent directories don't exist or if the path is not allowed
  */
 export declare function validatePath(requestedPath: string): Promise<string>;
-export interface FileResult {
-    content: string;
-    mimeType: string;
-    isImage: boolean;
-}
+export type { FileResult } from '../utils/files/base.js';
+type PdfPayload = {
+    metadata: PdfMetadata;
+    pages: PdfPageItem[];
+};
+type FileResultPayloads = PdfPayload;
 /**
  * Read file content from a URL
  * @param url URL to fetch content from
@@ -22,20 +25,17 @@ export declare function readFileFromUrl(url: string): Promise<FileResult>;
 /**
  * Read file content from the local filesystem
  * @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)
+ * @param options Read options (offset, length, sheet, range)
  * @returns File content or file result with metadata
  */
-export declare function readFileFromDisk(filePath: string, offset?: number, length?: number): Promise<FileResult>;
+export declare function readFileFromDisk(filePath: string, options?: ReadOptions): Promise<FileResult>;
 /**
  * Read a file from either the local filesystem or a URL
  * @param filePath Path to the file or URL
- * @param isUrl Whether the path is a URL
- * @param offset Starting line number to read from (default: 0)
- * @param length Maximum number of lines to read (default: from config or 1000)
+ * @param options Read options (isUrl, offset, length, sheet, range)
  * @returns File content or file result with metadata
  */
-export declare function readFile(filePath: string, isUrl?: boolean, offset?: number, length?: number): Promise<FileResult>;
+export declare function readFile(filePath: string, options?: ReadOptions): Promise<FileResult>;
 /**
  * Read file content without status messages for internal operations
  * This function preserves exact file content including original line endings,
@@ -53,6 +53,8 @@ export interface MultiFileResult {
     mimeType?: string;
     isImage?: boolean;
     error?: string;
+    isPdf?: boolean;
+    payload?: FileResultPayloads;
 }
 export declare function readMultipleFiles(paths: string[]): Promise<MultiFileResult[]>;
 export declare function createDirectory(dirPath: string): Promise<void>;
@@ -60,3 +62,12 @@ export declare function listDirectory(dirPath: string, depth?: number): Promise<
 export declare function moveFile(sourcePath: string, destinationPath: string): Promise<void>;
 export declare function searchFiles(rootPath: string, pattern: string): Promise<string[]>;
 export declare function getFileInfo(filePath: string): Promise<Record<string, any>>;
+/**
+ * Write content to a PDF file.
+ * Can create a new PDF from Markdown string, or modify an existing PDF using operations.
+ *
+ * @param filePath Path to the output PDF file
+ * @param content Markdown string (for creation) or array of operations (for modification)
+ * @param options Options for PDF generation or modification. For modification, can include `sourcePdf`.
+ */
+export declare function writePdf(filePath: string, content: string | PdfOperations[], outputPath?: string, options?: any): Promise<void>;