@wonderwhy-er/desktop-commander 0.1.0

package/dist/terminal-manager.js

@@ -0,0 +1,90 @@
+import { spawn } from 'child_process';
+import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
+export class TerminalManager {
+    constructor() {
+        this.sessions = new Map();
+    }
+    async executeCommand(command, timeoutMs = DEFAULT_COMMAND_TIMEOUT) {
+        const process = spawn(command, [], { shell: true });
+        let output = '';
+        // Ensure process.pid is defined before proceeding
+        if (!process.pid) {
+            throw new Error('Failed to get process ID');
+        }
+        const session = {
+            pid: process.pid,
+            process,
+            lastOutput: '',
+            isBlocked: false,
+            startTime: new Date()
+        };
+        this.sessions.set(process.pid, session);
+        return new Promise((resolve) => {
+            process.stdout.on('data', (data) => {
+                const text = data.toString();
+                output += text;
+                session.lastOutput += text;
+            });
+            process.stderr.on('data', (data) => {
+                const text = data.toString();
+                output += text;
+                session.lastOutput += text;
+            });
+            setTimeout(() => {
+                session.isBlocked = true;
+                resolve({
+                    pid: process.pid,
+                    output,
+                    isBlocked: true
+                });
+            }, timeoutMs);
+            process.on('exit', () => {
+                if (process.pid) {
+                    this.sessions.delete(process.pid);
+                }
+                resolve({
+                    pid: process.pid,
+                    output,
+                    isBlocked: false
+                });
+            });
+        });
+    }
+    getNewOutput(pid) {
+        const session = this.sessions.get(pid);
+        if (!session) {
+            return null;
+        }
+        const output = session.lastOutput;
+        session.lastOutput = '';
+        return output;
+    }
+    forceTerminate(pid) {
+        const session = this.sessions.get(pid);
+        if (!session) {
+            return false;
+        }
+        try {
+            session.process.kill('SIGINT');
+            setTimeout(() => {
+                if (this.sessions.has(pid)) {
+                    session.process.kill('SIGKILL');
+                }
+            }, 1000);
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to terminate process ${pid}:`, error);
+            return false;
+        }
+    }
+    listActiveSessions() {
+        const now = new Date();
+        return Array.from(this.sessions.values()).map(session => ({
+            pid: session.pid,
+            isBlocked: session.isBlocked,
+            runtime: now.getTime() - session.startTime.getTime()
+        }));
+    }
+}
+export const terminalManager = new TerminalManager();

package/dist/tools/command-block.d.ts

@@ -0,0 +1,18 @@
+export declare function blockCommand(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function unblockCommand(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function listBlockedCommands(): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/command-block.js

@@ -0,0 +1,62 @@
+import { commandManager } from '../command-manager.js';
+import { logToFile } from '../logging.js';
+import { BlockCommandArgsSchema, UnblockCommandArgsSchema } from './schemas.js';
+export async function blockCommand(args) {
+    await logToFile('Processing block_command request');
+    const parsed = BlockCommandArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for block_command: ${parsed.error}`);
+    }
+    const success = await commandManager.blockCommand(parsed.data.command);
+    if (!success) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Command '${parsed.data.command}' is already blocked.`
+                }],
+        };
+    }
+    await logToFile(`Added '${parsed.data.command}' to blocked commands`);
+    return {
+        content: [{
+                type: "text",
+                text: `Command '${parsed.data.command}' has been blocked. Current blocked commands: ${commandManager.listBlockedCommands().join(', ')}`
+            }],
+    };
+}
+export async function unblockCommand(args) {
+    await logToFile('Processing unblock_command request');
+    const parsed = UnblockCommandArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for unblock_command: ${parsed.error}`);
+    }
+    const success = await commandManager.unblockCommand(parsed.data.command);
+    if (!success) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Command '${parsed.data.command}' is not blocked.`
+                }],
+        };
+    }
+    await logToFile(`Removed '${parsed.data.command}' from blocked commands`);
+    return {
+        content: [{
+                type: "text",
+                text: `Command '${parsed.data.command}' has been unblocked. Current blocked commands: ${commandManager.listBlockedCommands().join(', ')}`
+            }],
+    };
+}
+export async function listBlockedCommands() {
+    await logToFile('Processing list_blocked_commands request');
+    const blockedList = commandManager.listBlockedCommands();
+    await logToFile(`Listed ${blockedList.length} blocked commands`);
+    return {
+        content: [{
+                type: "text",
+                text: blockedList.length > 0
+                    ? `Currently blocked commands:\n${blockedList.join('\n')}`
+                    : "No commands are currently blocked."
+            }],
+    };
+}

package/dist/tools/edit.d.ts

@@ -0,0 +1,10 @@
+interface SearchReplace {
+    search: string;
+    replace: string;
+}
+export declare function performSearchReplace(filePath: string, block: SearchReplace): Promise<void>;
+export declare function parseEditBlock(blockContent: string): Promise<{
+    filePath: string;
+    searchReplace: SearchReplace;
+}>;
+export {};

package/dist/tools/edit.js

@@ -0,0 +1,33 @@
+import { readFile, writeFile } from './filesystem.js';
+export async function performSearchReplace(filePath, block) {
+    const content = await readFile(filePath);
+    // Find first occurrence
+    const searchIndex = content.indexOf(block.search);
+    if (searchIndex === -1) {
+        throw new Error(`Search content not found in ${filePath}`);
+    }
+    // Replace content
+    const newContent = content.substring(0, searchIndex) +
+        block.replace +
+        content.substring(searchIndex + block.search.length);
+    await writeFile(filePath, newContent);
+}
+export async function parseEditBlock(blockContent) {
+    const lines = blockContent.split('\n');
+    // First line should be the file path
+    const filePath = lines[0].trim();
+    // Find the markers
+    const searchStart = lines.indexOf('<<<<<<< SEARCH');
+    const divider = lines.indexOf('=======');
+    const replaceEnd = lines.indexOf('>>>>>>> REPLACE');
+    if (searchStart === -1 || divider === -1 || replaceEnd === -1) {
+        throw new Error('Invalid edit block format - missing markers');
+    }
+    // Extract search and replace content
+    const search = lines.slice(searchStart + 1, divider).join('\n');
+    const replace = lines.slice(divider + 1, replaceEnd).join('\n');
+    return {
+        filePath,
+        searchReplace: { search, replace }
+    };
+}

package/dist/tools/execute.d.ts

@@ -0,0 +1,24 @@
+export declare function executeCommand(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function readOutput(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function forceTerminate(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+export declare function listSessions(): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/execute.js

@@ -0,0 +1,60 @@
+import { terminalManager } from '../terminal-manager.js';
+import { commandManager } from '../command-manager.js';
+import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
+export async function executeCommand(args) {
+    const parsed = ExecuteCommandArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for execute_command: ${parsed.error}`);
+    }
+    if (!commandManager.validateCommand(parsed.data.command)) {
+        throw new Error(`Command not allowed: ${parsed.data.command}`);
+    }
+    const result = await terminalManager.executeCommand(parsed.data.command, parsed.data.timeout_ms);
+    return {
+        content: [{
+                type: "text",
+                text: `Command started with PID ${result.pid}\nInitial output:\n${result.output}${result.isBlocked ? '\nCommand is still running. Use read_output to get more output.' : ''}`
+            }],
+    };
+}
+export async function readOutput(args) {
+    const parsed = ReadOutputArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for read_output: ${parsed.error}`);
+    }
+    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'
+            }],
+    };
+}
+export async function forceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for force_terminate: ${parsed.error}`);
+    }
+    const success = terminalManager.forceTerminate(parsed.data.pid);
+    return {
+        content: [{
+                type: "text",
+                text: success
+                    ? `Successfully initiated termination of session ${parsed.data.pid}`
+                    : `No active session found for PID ${parsed.data.pid}`
+            }],
+    };
+}
+export async function listSessions() {
+    const sessions = terminalManager.listActiveSessions();
+    return {
+        content: [{
+                type: "text",
+                text: sessions.length === 0
+                    ? 'No active sessions'
+                    : sessions.map(s => `PID: ${s.pid}, Blocked: ${s.isBlocked}, Runtime: ${Math.round(s.runtime / 1000)}s`).join('\n')
+            }],
+    };
+}

package/dist/tools/filesystem.d.ts

@@ -0,0 +1,10 @@
+export declare function validatePath(requestedPath: string): Promise<string>;
+export declare function readFile(filePath: string): Promise<string>;
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function readMultipleFiles(paths: string[]): Promise<string[]>;
+export declare function createDirectory(dirPath: string): Promise<void>;
+export declare function listDirectory(dirPath: string): Promise<string[]>;
+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>>;
+export declare function listAllowedDirectories(): string[];

package/dist/tools/filesystem.js

@@ -0,0 +1,133 @@
+import fs from "fs/promises";
+import path from "path";
+import os from 'os';
+// Store allowed directories
+const allowedDirectories = [
+    process.cwd(), // Current working directory
+    os.homedir() // User's home directory
+];
+// Normalize all paths consistently
+function normalizePath(p) {
+    return path.normalize(p).toLowerCase();
+}
+function expandHome(filepath) {
+    if (filepath.startsWith('~/') || filepath === '~') {
+        return path.join(os.homedir(), filepath.slice(1));
+    }
+    return filepath;
+}
+// Security utilities
+export async function validatePath(requestedPath) {
+    const expandedPath = expandHome(requestedPath);
+    const absolute = path.isAbsolute(expandedPath)
+        ? path.resolve(expandedPath)
+        : path.resolve(process.cwd(), expandedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within allowed directories
+    const isAllowed = allowedDirectories.some(dir => normalizedRequested.startsWith(normalizePath(dir)));
+    if (!isAllowed) {
+        throw new Error(`Access denied - path outside allowed directories: ${absolute}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        const isRealPathAllowed = allowedDirectories.some(dir => normalizedReal.startsWith(normalizePath(dir)));
+        if (!isRealPathAllowed) {
+            throw new Error("Access denied - symlink target outside allowed directories");
+        }
+        return realPath;
+    }
+    catch (error) {
+        // For new files that don't exist yet, verify parent directory
+        const parentDir = path.dirname(absolute);
+        try {
+            const realParentPath = await fs.realpath(parentDir);
+            const normalizedParent = normalizePath(realParentPath);
+            const isParentAllowed = allowedDirectories.some(dir => normalizedParent.startsWith(normalizePath(dir)));
+            if (!isParentAllowed) {
+                throw new Error("Access denied - parent directory outside allowed directories");
+            }
+            return absolute;
+        }
+        catch {
+            throw new Error(`Parent directory does not exist: ${parentDir}`);
+        }
+    }
+}
+// File operation tools
+export async function readFile(filePath) {
+    const validPath = await validatePath(filePath);
+    return fs.readFile(validPath, "utf-8");
+}
+export async function writeFile(filePath, content) {
+    const validPath = await validatePath(filePath);
+    await fs.writeFile(validPath, content, "utf-8");
+}
+export async function readMultipleFiles(paths) {
+    return Promise.all(paths.map(async (filePath) => {
+        try {
+            const validPath = await validatePath(filePath);
+            const content = await fs.readFile(validPath, "utf-8");
+            return `${filePath}:\n${content}\n`;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return `${filePath}: Error - ${errorMessage}`;
+        }
+    }));
+}
+export async function createDirectory(dirPath) {
+    const validPath = await validatePath(dirPath);
+    await fs.mkdir(validPath, { recursive: true });
+}
+export async function listDirectory(dirPath) {
+    const validPath = await validatePath(dirPath);
+    const entries = await fs.readdir(validPath, { withFileTypes: true });
+    return entries.map((entry) => `${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}`);
+}
+export async function moveFile(sourcePath, destinationPath) {
+    const validSourcePath = await validatePath(sourcePath);
+    const validDestPath = await validatePath(destinationPath);
+    await fs.rename(validSourcePath, validDestPath);
+}
+export async function searchFiles(rootPath, pattern) {
+    const results = [];
+    async function search(currentPath) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            try {
+                await validatePath(fullPath);
+                if (entry.name.toLowerCase().includes(pattern.toLowerCase())) {
+                    results.push(fullPath);
+                }
+                if (entry.isDirectory()) {
+                    await search(fullPath);
+                }
+            }
+            catch (error) {
+                continue;
+            }
+        }
+    }
+    const validPath = await validatePath(rootPath);
+    await search(validPath);
+    return results;
+}
+export async function getFileInfo(filePath) {
+    const validPath = await validatePath(filePath);
+    const stats = await fs.stat(validPath);
+    return {
+        size: stats.size,
+        created: stats.birthtime,
+        modified: stats.mtime,
+        accessed: stats.atime,
+        isDirectory: stats.isDirectory(),
+        isFile: stats.isFile(),
+        permissions: stats.mode.toString(8).slice(-3),
+    };
+}
+export function listAllowedDirectories() {
+    return allowedDirectories;
+}

package/dist/tools/process.d.ts

@@ -0,0 +1,12 @@
+export declare function listProcesses(): Promise<{
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}>;
+export declare function killProcess(args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/tools/process.js

@@ -0,0 +1,47 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import { KillProcessArgsSchema } from './schemas.js';
+const execAsync = promisify(exec);
+export async function listProcesses() {
+    const command = os.platform() === 'win32' ? 'tasklist' : 'ps aux';
+    try {
+        const { stdout } = await execAsync(command);
+        const processes = stdout.split('\n')
+            .slice(1)
+            .filter(Boolean)
+            .map(line => {
+            const parts = line.split(/\s+/);
+            return {
+                pid: parseInt(parts[1]),
+                command: parts[parts.length - 1],
+                cpu: parts[2],
+                memory: parts[3],
+            };
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: processes.map(p => `PID: ${p.pid}, Command: ${p.command}, CPU: ${p.cpu}, Memory: ${p.memory}`).join('\n')
+                }],
+        };
+    }
+    catch (error) {
+        throw new Error('Failed to list processes');
+    }
+}
+export async function killProcess(args) {
+    const parsed = KillProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        throw new Error(`Invalid arguments for kill_process: ${parsed.error}`);
+    }
+    try {
+        process.kill(parsed.data.pid);
+        return {
+            content: [{ type: "text", text: `Successfully terminated process ${parsed.data.pid}` }],
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to kill process: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/dist/tools/schemas.d.ts

@@ -0,0 +1,119 @@
+import { z } from "zod";
+export declare const ExecuteCommandArgsSchema: z.ZodObject<{
+    command: z.ZodString;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+    timeout_ms?: number | undefined;
+}, {
+    command: string;
+    timeout_ms?: number | undefined;
+}>;
+export declare const ReadOutputArgsSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+}, {
+    pid: number;
+}>;
+export declare const ForceTerminateArgsSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+}, {
+    pid: number;
+}>;
+export declare const ListSessionsArgsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const KillProcessArgsSchema: z.ZodObject<{
+    pid: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    pid: number;
+}, {
+    pid: number;
+}>;
+export declare const BlockCommandArgsSchema: z.ZodObject<{
+    command: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+}, {
+    command: string;
+}>;
+export declare const UnblockCommandArgsSchema: z.ZodObject<{
+    command: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    command: string;
+}, {
+    command: string;
+}>;
+export declare const ReadFileArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+}, {
+    paths: string[];
+}>;
+export declare const WriteFileArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+}, {
+    path: string;
+    content: string;
+}>;
+export declare const CreateDirectoryArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const ListDirectoryArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const MoveFileArgsSchema: z.ZodObject<{
+    source: z.ZodString;
+    destination: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    destination: string;
+}, {
+    source: string;
+    destination: string;
+}>;
+export declare const SearchFilesArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    pattern: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    pattern: string;
+}, {
+    path: string;
+    pattern: string;
+}>;
+export declare const GetFileInfoArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+export declare const EditBlockArgsSchema: z.ZodObject<{
+    blockContent: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    blockContent: string;
+}, {
+    blockContent: string;
+}>;

package/dist/tools/schemas.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+// Terminal tools schemas
+export const ExecuteCommandArgsSchema = z.object({
+    command: z.string(),
+    timeout_ms: z.number().optional(),
+});
+export const ReadOutputArgsSchema = z.object({
+    pid: z.number(),
+});
+export const ForceTerminateArgsSchema = z.object({
+    pid: z.number(),
+});
+export const ListSessionsArgsSchema = z.object({});
+export const KillProcessArgsSchema = z.object({
+    pid: z.number(),
+});
+export const BlockCommandArgsSchema = z.object({
+    command: z.string(),
+});
+export const UnblockCommandArgsSchema = z.object({
+    command: z.string(),
+});
+// Filesystem tools schemas
+export const ReadFileArgsSchema = z.object({
+    path: z.string(),
+});
+export const ReadMultipleFilesArgsSchema = z.object({
+    paths: z.array(z.string()),
+});
+export const WriteFileArgsSchema = z.object({
+    path: z.string(),
+    content: z.string(),
+});
+export const CreateDirectoryArgsSchema = z.object({
+    path: z.string(),
+});
+export const ListDirectoryArgsSchema = z.object({
+    path: z.string(),
+});
+export const MoveFileArgsSchema = z.object({
+    source: z.string(),
+    destination: z.string(),
+});
+export const SearchFilesArgsSchema = z.object({
+    path: z.string(),
+    pattern: z.string(),
+});
+export const GetFileInfoArgsSchema = z.object({
+    path: z.string(),
+});
+// Edit tools schemas
+export const EditBlockArgsSchema = z.object({
+    blockContent: z.string(),
+});