@wonderwhy-er/desktop-commander 0.2.38 → 0.2.39

package/dist/tools/macos-control/types.d.ts

@@ -1,129 +0,0 @@
-export type MacosControlErrorCode = 'UNSUPPORTED_PLATFORM' | 'HELPER_NOT_FOUND' | 'HELPER_EXEC_FAILED' | 'HELPER_PROTOCOL_ERROR' | 'PERMISSION_DENIED' | 'INVALID_ARGUMENT' | 'NOT_FOUND' | 'TIMEOUT' | 'ACTION_FAILED' | 'CDP_CONNECT_FAILED' | 'CDP_NOT_CONNECTED' | 'CDP_CALL_FAILED' | 'INTERNAL_ERROR';
-export interface MacosControlError {
-    code: MacosControlErrorCode;
-    message: string;
-    details?: Record<string, unknown>;
-    retriable?: boolean;
-}
-export interface MacosControlResult<T = unknown> {
-    ok: boolean;
-    data?: T;
-    error?: MacosControlError;
-}
-export interface AxElement {
-    id: string;
-    app: string;
-    pid: number;
-    role: string;
-    title?: string;
-    label?: string;
-    desc?: string;
-    text?: string;
-    checked?: boolean;
-    selected?: boolean;
-    focused?: boolean;
-    actions?: string[];
-    bounds: [number, number, number, number];
-}
-export interface AxAppInfo {
-    name: string;
-    pid: number;
-    bundleId?: string;
-    active: boolean;
-}
-export interface AxStatus {
-    platform: NodeJS.Platform;
-    hasPermission: boolean;
-    helperPath?: string;
-    helperVersion?: string;
-    processInfo?: string;
-}
-export interface AxBatchCommand {
-    action: 'activate' | 'find' | 'click' | 'find_and_click' | 'type' | 'key' | 'wait' | 'wait_for' | 'get_state' | 'scroll';
-    app?: string;
-    text?: string;
-    role?: string;
-    id?: string;
-    timeout_ms?: number;
-    depth?: number;
-    limit?: number;
-    key?: string;
-    modifiers?: string[];
-    index?: number;
-    if_exists?: boolean;
-    ms?: number;
-    x?: number;
-    y?: number;
-    direction?: 'up' | 'down';
-    amount?: number;
-}
-export interface AxBatchResultItem {
-    action: string;
-    success: boolean;
-    skipped?: boolean;
-    element?: AxElement;
-    error?: string;
-    [key: string]: unknown;
-}
-export interface AxBatchResult {
-    success: boolean;
-    results: AxBatchResultItem[];
-    failedAt: number | null;
-    completed: number;
-    total: number;
-}
-export interface ElectronDebugTarget {
-    id: string;
-    type: string;
-    title: string;
-    url: string;
-    webSocketDebuggerUrl?: string;
-}
-export interface ElectronDebugAttachResult {
-    sessionId: string;
-    host: string;
-    port: number;
-    targetId: string;
-    targetTitle: string;
-    targetUrl: string;
-    availableTargets: Array<{
-        id: string;
-        title: string;
-        url: string;
-        type: string;
-    }>;
-}
-export interface ElectronDebugEvalResult {
-    result?: unknown;
-    type?: string;
-    description?: string;
-    subtype?: string;
-}
-export interface AxElementSignature {
-    app: string;
-    role: string;
-    title?: string;
-    label?: string;
-    text?: string;
-    bounds?: [number, number, number, number];
-}
-export interface HelperRequest {
-    command: string;
-    args?: Record<string, unknown>;
-    requestId?: string;
-}
-export interface HelperError {
-    code: string;
-    message: string;
-    details?: Record<string, unknown>;
-}
-export interface HelperResponse<T = unknown> {
-    ok: boolean;
-    data?: T;
-    error?: HelperError;
-    meta?: {
-        requestId?: string;
-        durationMs?: number;
-        [key: string]: unknown;
-    };
-}

package/dist/tools/pdf-processor.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tools/pdf-processor.js

@@ -1,3 +0,0 @@
-export {};
-// PDF processing is no longer needed - PDFs are handled like images as base64 documents
-// This file is kept for potential future enhancements but currently unused

package/dist/tools/search.d.ts

@@ -1,32 +0,0 @@
-export interface SearchResult {
-    file: string;
-    line: number;
-    match: string;
-}
-export declare function searchCode(options: {
-    rootPath: string;
-    pattern: string;
-    filePattern?: string;
-    ignoreCase?: boolean;
-    maxResults?: number;
-    includeHidden?: boolean;
-    contextLines?: number;
-}): Promise<SearchResult[]>;
-export declare function searchCodeFallback(options: {
-    rootPath: string;
-    pattern: string;
-    filePattern?: string;
-    ignoreCase?: boolean;
-    maxResults?: number;
-    excludeDirs?: string[];
-    contextLines?: number;
-}): Promise<SearchResult[]>;
-export declare function searchTextInFiles(options: {
-    rootPath: string;
-    pattern: string;
-    filePattern?: string;
-    ignoreCase?: boolean;
-    maxResults?: number;
-    includeHidden?: boolean;
-    contextLines?: number;
-}): Promise<SearchResult[]>;

package/dist/tools/search.js

@@ -1,202 +0,0 @@
-import { spawn } from 'child_process';
-import path from 'path';
-import fs from 'fs/promises';
-import { validatePath } from './filesystem.js';
-import { rgPath } from '@vscode/ripgrep';
-import { capture } from "../utils/capture.js";
-// Function to search file contents using ripgrep
-export async function searchCode(options) {
-    const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, includeHidden = false, contextLines = 0 } = options;
-    // Validate path for security
-    const validPath = await validatePath(rootPath);
-    // Build command arguments
-    const args = [
-        '--json', // Output in JSON format for easier parsing
-        '--line-number', // Include line numbers
-    ];
-    if (ignoreCase) {
-        args.push('-i');
-    }
-    if (maxResults) {
-        args.push('-m', maxResults.toString());
-    }
-    if (includeHidden) {
-        args.push('--hidden');
-    }
-    if (contextLines > 0) {
-        args.push('-C', contextLines.toString());
-    }
-    if (filePattern) {
-        const patterns = filePattern
-            .split('|')
-            .map(p => p.trim()) // remove surrounding spaces
-            .filter(Boolean); // drop empty tokens
-        // If all patterns were empty, return no results
-        if (patterns.length === 0) {
-            return [];
-        }
-        patterns.forEach(p => args.push('-g', p));
-    }
-    // Add pattern and path
-    args.push(pattern, validPath);
-    // Run ripgrep command
-    return new Promise((resolve, reject) => {
-        const results = [];
-        const rg = spawn(rgPath, args);
-        let stdoutBuffer = '';
-        // Store a reference to the child process for potential termination
-        const childProcess = rg;
-        // Store in a process list - this could be expanded to a global registry
-        // of running search processes if needed for management
-        globalThis.currentSearchProcess = childProcess;
-        rg.stdout.on('data', (data) => {
-            stdoutBuffer += data.toString();
-        });
-        rg.stderr.on('data', (data) => {
-            console.error(`ripgrep error: ${data}`);
-        });
-        rg.on('close', (code) => {
-            // Clean up the global reference
-            if (globalThis.currentSearchProcess === childProcess) {
-                delete globalThis.currentSearchProcess;
-            }
-            if (code === 0 || code === 1) {
-                // Process the buffered output
-                const lines = stdoutBuffer.trim().split('\n');
-                for (const line of lines) {
-                    if (!line)
-                        continue;
-                    try {
-                        const result = JSON.parse(line);
-                        if (result.type === 'match') {
-                            result.data.submatches.forEach((submatch) => {
-                                results.push({
-                                    file: result.data.path.text,
-                                    line: result.data.line_number,
-                                    match: submatch.match.text
-                                });
-                            });
-                        }
-                        else if (result.type === 'context' && contextLines > 0) {
-                            results.push({
-                                file: result.data.path.text,
-                                line: result.data.line_number,
-                                match: result.data.lines.text.trim()
-                            });
-                        }
-                    }
-                    catch (error) {
-                        const errorMessage = error instanceof Error ? error.message : String(error);
-                        capture('server_request_error', { error: `Error parsing ripgrep output: ${errorMessage}` });
-                        console.error(`Error parsing ripgrep output: ${errorMessage}`);
-                    }
-                }
-                resolve(results);
-            }
-            else {
-                reject(new Error(`ripgrep process exited with code ${code}`));
-            }
-        });
-    });
-}
-// Fallback implementation using Node.js for environments without ripgrep
-export async function searchCodeFallback(options) {
-    const { rootPath, pattern, filePattern, ignoreCase = true, maxResults = 1000, excludeDirs = ['node_modules', '.git'], contextLines = 0 } = options;
-    const validPath = await validatePath(rootPath);
-    const results = [];
-    const regex = new RegExp(pattern, ignoreCase ? 'i' : '');
-    // Handle filePattern similarly to main implementation
-    let fileRegex = null;
-    if (filePattern) {
-        const patterns = filePattern
-            .split('|')
-            .map(p => p.trim())
-            .filter(Boolean);
-        // If all patterns were empty, return no results
-        if (patterns.length === 0) {
-            return [];
-        }
-        // Create a regex that matches any of the patterns
-        const combinedPattern = patterns.map(p => p.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.')).join('|');
-        fileRegex = new RegExp(`^(${combinedPattern})$`);
-    }
-    async function searchDir(dirPath) {
-        if (results.length >= maxResults)
-            return;
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (results.length >= maxResults)
-                    break;
-                const fullPath = path.join(dirPath, entry.name);
-                try {
-                    await validatePath(fullPath);
-                    if (entry.isDirectory()) {
-                        if (!excludeDirs.includes(entry.name)) {
-                            await searchDir(fullPath);
-                        }
-                    }
-                    else if (entry.isFile()) {
-                        if (!fileRegex || fileRegex.test(entry.name)) {
-                            const content = await fs.readFile(fullPath, 'utf-8');
-                            const lines = content.split('\n');
-                            for (let i = 0; i < lines.length; i++) {
-                                if (regex.test(lines[i])) {
-                                    // Add the matched line
-                                    results.push({
-                                        file: fullPath,
-                                        line: i + 1,
-                                        match: lines[i].trim()
-                                    });
-                                    // Add context lines
-                                    if (contextLines > 0) {
-                                        const startIdx = Math.max(0, i - contextLines);
-                                        const endIdx = Math.min(lines.length - 1, i + contextLines);
-                                        for (let j = startIdx; j <= endIdx; j++) {
-                                            if (j !== i) { // Skip the match line as it's already added
-                                                results.push({
-                                                    file: fullPath,
-                                                    line: j + 1,
-                                                    match: lines[j].trim()
-                                                });
-                                            }
-                                        }
-                                    }
-                                    if (results.length >= maxResults)
-                                        break;
-                                }
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    // Skip files/directories we can't access
-                    continue;
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read
-        }
-    }
-    await searchDir(validPath);
-    return results;
-}
-// Main function that tries ripgrep first, falls back to native implementation
-export async function searchTextInFiles(options) {
-    try {
-        // For better performance and consistency, prefer the search session manager
-        // when doing content search, but keep the original direct ripgrep approach as primary
-        return await searchCode(options);
-    }
-    catch (error) {
-        capture('searchTextInFiles_ripgrep_fallback', {
-            error: error instanceof Error ? error.message : 'Unknown error'
-        });
-        // Use consistent exclusions - remove 'dist' to match ripgrep behavior
-        return searchCodeFallback({
-            ...options,
-            excludeDirs: ['node_modules', '.git']
-        });
-    }
-}