centaurus-cli 3.0.1 → 3.1.0

package/dist/context/handlers/wsl-handler.js

@@ -1,649 +1,577 @@
-/**
- * WSL Handler for Windows Subsystem for Linux
- */
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-import { SubshellConnectionError, SubshellExecutionError } from '../types.js';
-import { randomBytes } from 'crypto';
-import * as os from 'os';
+import { exec, spawn } from "child_process";
+import { promisify } from "util";
+import { SubshellConnectionError, SubshellExecutionError } from "../types.js";
+import { randomBytes } from "crypto";
+import * as os from "os";
 const execAsync = promisify(exec);
-/**
- * WSL Handler implementation
- */
-export class WSLHandler {
-    type = 'wsl';
-    detectionPatterns = [
-        /^wsl$/,
-        /^wsl\s+/,
-        /^wsl\.exe\s+/,
-    ];
-    config = null;
-    currentWorkingDirectory = '~';
-    shellType = 'bash';
-    sessionId = '';
-    shellProcess = null;
-    commandQueue = [];
-    currentOutput = '';
-    currentError = '';
-    // Streaming output callback for real-time display
-    onOutputCallback = null;
-    /**
-     * Set a callback to receive real-time output from commands
-     * This is essential for interactive commands like sudo that need user input
-     */
-    setOutputCallback(callback) {
-        this.onOutputCallback = callback;
-    }
-    /**
-     * Write data to the shell's stdin (for user input like passwords)
-     */
-    writeToStdin(data) {
-        if (this.shellProcess && this.shellProcess.stdin && !this.shellProcess.stdin.destroyed) {
-            this.shellProcess.stdin.write(data);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Detect if a command should trigger this handler
-     */
-    detect(command) {
-        return this.detectionPatterns.some(pattern => pattern.test(command));
-    }
-    /**
-     * Connect to the WSL environment
-     */
-    async connect(command, cwd) {
-        this.sessionId = randomBytes(16).toString('hex');
-        try {
-            // Verify WSL is available (Windows only)
-            this.verifyWSLAvailable();
-            // Parse WSL command to extract distribution
-            this.config = await this.parseWSLCommand(command);
-            // Spawn interactive shell
-            await this.spawnInteractiveShell();
-            // Detect shell type
-            this.shellType = await this.detectShellType();
-            // Get initial working directory
-            this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
-            return {
-                type: 'wsl',
-                handler: this,
-                metadata: {
-                    workingDirectory: this.currentWorkingDirectory,
-                    shell: this.shellType,
-                    os: 'linux',
-                    distroName: this.config.distribution,
-                },
-                connectionState: 'connected',
-                sessionId: this.sessionId,
-            };
-        }
-        catch (error) {
-            throw new SubshellConnectionError('wsl', error instanceof Error ? error.message : 'Unknown error', false);
-        }
+class WSLHandler {
+  type = "wsl";
+  detectionPatterns = [
+    /^wsl$/,
+    /^wsl\s+/,
+    /^wsl\.exe\s+/
+  ];
+  config = null;
+  currentWorkingDirectory = "~";
+  shellType = "bash";
+  sessionId = "";
+  shellProcess = null;
+  commandQueue = [];
+  currentOutput = "";
+  currentError = "";
+  // Streaming output callback for real-time display
+  onOutputCallback = null;
+  /**
+   * Set a callback to receive real-time output from commands
+   * This is essential for interactive commands like sudo that need user input
+   */
+  setOutputCallback(callback) {
+    this.onOutputCallback = callback;
+  }
+  /**
+   * Write data to the shell's stdin (for user input like passwords)
+   */
+  writeToStdin(data) {
+    if (this.shellProcess && this.shellProcess.stdin && !this.shellProcess.stdin.destroyed) {
+      this.shellProcess.stdin.write(data);
+      return true;
     }
-    /**
-     * Spawn an interactive shell process
-     */
-    async spawnInteractiveShell() {
-        if (!this.config) {
-            throw new Error('Config not initialized');
-        }
-        const distro = this.config.distribution.trim().replace(/\0/g, '');
-        return new Promise((resolve, reject) => {
-            // Spawn wsl.exe with the distribution
-            this.shellProcess = spawn('wsl.exe', ['-d', distro], {
-                stdio: ['pipe', 'pipe', 'pipe'],
-                shell: false,
-            });
-            if (!this.shellProcess.stdout || !this.shellProcess.stderr || !this.shellProcess.stdin) {
-                reject(new Error('Failed to create shell process streams'));
-                return;
-            }
-            let hasResolved = false;
-            let errorOutput = '';
-            let initCommandSent = false;
-            // Set up output handlers
-            this.shellProcess.stdout.on('data', (data) => {
-                const text = data.toString();
-                this.currentOutput += text;
-                // Stream to callback if registered (for real-time UI display)
-                if (this.onOutputCallback) {
-                    this.onOutputCallback(text, 'stdout');
-                }
-                // If we get any output, the shell is working
-                if (!hasResolved) {
-                    hasResolved = true;
-                    resolve();
-                }
-            });
-            this.shellProcess.stderr.on('data', (data) => {
-                const text = data.toString();
-                this.currentError += text;
-                errorOutput += text;
-                // Stream to callback if registered (for real-time UI display)
-                if (this.onOutputCallback) {
-                    this.onOutputCallback(text, 'stderr');
-                }
-            });
-            this.shellProcess.on('exit', (code) => {
-                if (!hasResolved) {
-                    hasResolved = true;
-                    // Check for common WSL errors
-                    if (errorOutput.includes('HCS_E_SERVICE_NOT_AVAILABLE')) {
-                        reject(new Error('WSL service is not running. Try running "wsl --shutdown" and then try again, or restart your computer.'));
-                    }
-                    else if (errorOutput.includes('required feature is not installed')) {
-                        reject(new Error('WSL is not properly installed or enabled. Please ensure WSL 2 is installed and the Virtual Machine Platform feature is enabled.'));
-                    }
-                    else {
-                        reject(new Error(`WSL process exited with code ${code}. Error: ${errorOutput || 'No error output'}`));
-                    }
-                }
-                this.shellProcess = null;
-            });
-            this.shellProcess.on('error', (error) => {
-                if (!hasResolved) {
-                    hasResolved = true;
-                    reject(new Error(`Failed to spawn WSL process: ${error.message}`));
-                }
-            });
-            // Wait for stdin to be ready, then send initialization command
-            const sendInitCommand = () => {
-                if (!initCommandSent && this.shellProcess && this.shellProcess.stdin && !this.shellProcess.stdin.destroyed) {
-                    initCommandSent = true;
-                    this.shellProcess.stdin.write('echo "CENTAURUS_READY"\n');
-                }
-            };
-            // Try to send command immediately if stdin is already writable
-            if (this.shellProcess.stdin.writable) {
-                sendInitCommand();
-            }
-            else {
-                // Otherwise wait for the 'ready' event on stdin
-                this.shellProcess.stdin.once('ready', sendInitCommand);
-            }
-            // Fallback: also try after a small delay in case ready event doesn't fire
-            setTimeout(() => {
-                sendInitCommand();
-            }, 200);
-            // Timeout if we don't get a response
-            // WSL cold-start can take 10+ seconds on first run
-            setTimeout(() => {
-                if (!hasResolved) {
-                    hasResolved = true;
-                    reject(new Error(`WSL shell initialization timed out. Error: ${errorOutput || 'No error output'}`));
-                }
-            }, 15000);
-        });
+    return false;
+  }
+  /**
+   * Detect if a command should trigger this handler
+   */
+  detect(command) {
+    return this.detectionPatterns.some((pattern) => pattern.test(command));
+  }
+  /**
+   * Connect to the WSL environment
+   */
+  async connect(command, cwd) {
+    this.sessionId = randomBytes(16).toString("hex");
+    try {
+      this.verifyWSLAvailable();
+      this.config = await this.parseWSLCommand(command);
+      await this.spawnInteractiveShell();
+      this.shellType = await this.detectShellType();
+      this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
+      return {
+        type: "wsl",
+        handler: this,
+        metadata: {
+          workingDirectory: this.currentWorkingDirectory,
+          shell: this.shellType,
+          os: "linux",
+          distroName: this.config.distribution
+        },
+        connectionState: "connected",
+        sessionId: this.sessionId
+      };
+    } catch (error) {
+      throw new SubshellConnectionError(
+        "wsl",
+        error instanceof Error ? error.message : "Unknown error",
+        false
+      );
     }
-    /**
-     * Disconnect from the WSL environment
-     */
-    async disconnect() {
-        if (this.shellProcess) {
-            this.shellProcess.kill();
-            this.shellProcess = null;
-        }
-        this.config = null;
-    }
-    /**
-     * Check if this handler is currently connected to a WSL environment
-     */
-    isConnected() {
-        return this.config !== null && this.shellProcess !== null;
-    }
-    /**
-     * Execute a command in the WSL environment
-     */
-    async executeCommand(command) {
-        if (!this.config) {
-            throw new SubshellExecutionError(command, 'Not connected to WSL - config is null');
-        }
-        if (!this.shellProcess) {
-            throw new SubshellExecutionError(command, 'Not connected to WSL - shell process is null');
-        }
-        if (!this.shellProcess.stdin) {
-            throw new SubshellExecutionError(command, 'Not connected to WSL - stdin is null');
-        }
-        if (this.shellProcess.killed || this.shellProcess.exitCode !== null) {
-            throw new SubshellExecutionError(command, 'Not connected to WSL - shell process has exited');
-        }
-        try {
-            // Clear previous output
-            this.currentOutput = '';
-            this.currentError = '';
-            // Unique PWD tag for this session
-            const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
-            // Build command with pwd tracking
-            let commandWithPwd;
-            const trimmedCommand = command.trim();
-            // Check if this is a cd command
-            if (trimmedCommand.startsWith('cd ') || trimmedCommand === 'cd') {
-                // For cd commands, execute directly without prepending current directory
-                // The shell maintains its own state
-                commandWithPwd = `${command}; echo "${pwdTag}:$(pwd)"\n`;
-            }
-            else {
-                // For other commands, ensure we're in the right directory first
-                commandWithPwd = `cd ${this.currentWorkingDirectory} && ${command}; echo "${pwdTag}:$(pwd)"\n`;
-            }
-            // Send command to shell
-            this.shellProcess.stdin.write(commandWithPwd);
-            // Wait for command to complete (look for the pwd marker)
-            const result = await this.waitForCommandCompletion(30000);
-            return result;
+  }
+  /**
+   * Spawn an interactive shell process
+   */
+  async spawnInteractiveShell() {
+    if (!this.config) {
+      throw new Error("Config not initialized");
+    }
+    const distro = this.config.distribution.trim().replace(/\0/g, "");
+    return new Promise((resolve, reject) => {
+      this.shellProcess = spawn("wsl.exe", ["-d", distro], {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false
+      });
+      if (!this.shellProcess.stdout || !this.shellProcess.stderr || !this.shellProcess.stdin) {
+        reject(new Error("Failed to create shell process streams"));
+        return;
+      }
+      let hasResolved = false;
+      let errorOutput = "";
+      let initCommandSent = false;
+      this.shellProcess.stdout.on("data", (data) => {
+        const text = data.toString();
+        this.currentOutput += text;
+        if (this.onOutputCallback) {
+          this.onOutputCallback(text, "stdout");
         }
-        catch (error) {
-            return {
-                stdout: '',
-                stderr: error.message || 'Command execution failed',
-                exitCode: 1,
-            };
+        if (!hasResolved) {
+          hasResolved = true;
+          resolve();
         }
+      });
+      this.shellProcess.stderr.on("data", (data) => {
+        const text = data.toString();
+        this.currentError += text;
+        errorOutput += text;
+        if (this.onOutputCallback) {
+          this.onOutputCallback(text, "stderr");
+        }
+      });
+      this.shellProcess.on("exit", (code) => {
+        if (!hasResolved) {
+          hasResolved = true;
+          if (errorOutput.includes("HCS_E_SERVICE_NOT_AVAILABLE")) {
+            reject(new Error('WSL service is not running. Try running "wsl --shutdown" and then try again, or restart your computer.'));
+          } else if (errorOutput.includes("required feature is not installed")) {
+            reject(new Error("WSL is not properly installed or enabled. Please ensure WSL 2 is installed and the Virtual Machine Platform feature is enabled."));
+          } else {
+            reject(new Error(`WSL process exited with code ${code}. Error: ${errorOutput || "No error output"}`));
+          }
+        }
+        this.shellProcess = null;
+      });
+      this.shellProcess.on("error", (error) => {
+        if (!hasResolved) {
+          hasResolved = true;
+          reject(new Error(`Failed to spawn WSL process: ${error.message}`));
+        }
+      });
+      const sendInitCommand = () => {
+        if (!initCommandSent && this.shellProcess && this.shellProcess.stdin && !this.shellProcess.stdin.destroyed) {
+          initCommandSent = true;
+          this.shellProcess.stdin.write('echo "CENTAURUS_READY"\n');
+        }
+      };
+      if (this.shellProcess.stdin.writable) {
+        sendInitCommand();
+      } else {
+        this.shellProcess.stdin.once("ready", sendInitCommand);
+      }
+      setTimeout(() => {
+        sendInitCommand();
+      }, 200);
+      setTimeout(() => {
+        if (!hasResolved) {
+          hasResolved = true;
+          reject(new Error(`WSL shell initialization timed out. Error: ${errorOutput || "No error output"}`));
+        }
+      }, 15e3);
+    });
+  }
+  /**
+   * Disconnect from the WSL environment
+   */
+  async disconnect() {
+    if (this.shellProcess) {
+      this.shellProcess.kill();
+      this.shellProcess = null;
     }
-    /**
-     * Wait for command completion by monitoring output
-     */
-    async waitForCommandCompletion(timeoutMs = 30000) {
-        const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
-        const pwdRegex = new RegExp(`${pwdTag}:(.+)$`, 'm');
-        const removeRegex = new RegExp(`${pwdTag}:.+$`, 'm');
-        return new Promise((resolve, reject) => {
-            const startTime = Date.now();
-            const checkInterval = setInterval(() => {
-                if (timeoutMs > 0 && Date.now() - startTime >= timeoutMs) {
-                    clearInterval(checkInterval);
-                    reject(new Error(`Command execution timed out after ${timeoutMs}ms`));
-                    return;
-                }
-                const pwdMatch = this.currentOutput.match(pwdRegex);
-                if (pwdMatch) {
-                    clearInterval(checkInterval);
-                    // Extract working directory
-                    const newCwd = pwdMatch[1].trim();
-                    this.currentWorkingDirectory = newCwd;
-                    // Clean output
-                    const cleanStdout = this.currentOutput
-                        .replace(removeRegex, '')
-                        .trim();
-                    resolve({
-                        stdout: cleanStdout,
-                        stderr: this.currentError,
-                        exitCode: 0,
-                    });
-                }
-            }, 100);
-        });
+    this.config = null;
+  }
+  /**
+   * Check if this handler is currently connected to a WSL environment
+   */
+  isConnected() {
+    return this.config !== null && this.shellProcess !== null;
+  }
+  /**
+   * Execute a command in the WSL environment
+   */
+  async executeCommand(command) {
+    if (!this.config) {
+      throw new SubshellExecutionError(command, "Not connected to WSL - config is null");
     }
-    /**
-     * Read a file from the WSL filesystem
-     */
-    async readFile(path) {
-        if (!this.config) {
-            throw new Error('Not connected to WSL');
-        }
-        const distro = this.config.distribution.trim().replace(/\0/g, '');
-        const wslPath = this.resolveWSLPath(path);
-        // Use base64 to avoid encoding issues and binary-safe transfer
-        const command = `wsl.exe -d ${distro} -- bash -c "base64 '${wslPath}' 2>/dev/null || cat '${wslPath}' | base64"`;
-        try {
-            const { stdout } = await execAsync(command);
-            const b64 = stdout.replace(/\s+/g, '');
-            return Buffer.from(b64, 'base64').toString('utf-8');
-        }
-        catch (error) {
-            throw new Error(`Failed to read file ${path}: ${error.message}`);
-        }
+    if (!this.shellProcess) {
+      throw new SubshellExecutionError(command, "Not connected to WSL - shell process is null");
     }
-    /**
-     * Write a file to the WSL filesystem
-     */
-    async writeFile(path, content) {
-        if (!this.config) {
-            throw new Error('Not connected to WSL');
-        }
-        const distro = this.config.distribution.trim().replace(/\0/g, '');
-        const wslPath = this.resolveWSLPath(path);
-        // Use base64-encoded, chunked writes to avoid shell arg/command length limits
-        const inputBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
-        const base64Content = inputBuffer.toString('base64');
-        const CHUNK_SIZE = 32000; // conservative size per command
-        try {
-            // Truncate/initialize file
-            const truncateCmd = `wsl.exe -d ${distro} -- bash -c ": > '${wslPath}'"`;
-            await execAsync(truncateCmd);
-            // Write in chunks
-            for (let i = 0; i < base64Content.length; i += CHUNK_SIZE) {
-                const chunk = base64Content.slice(i, i + CHUNK_SIZE);
-                const writeCmd = `wsl.exe -d ${distro} -- bash -c "echo '${chunk}' | base64 -d >> '${wslPath}'"`;
-                await execAsync(writeCmd);
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to write file ${path}: ${error.message}`);
-        }
+    if (!this.shellProcess.stdin) {
+      throw new SubshellExecutionError(command, "Not connected to WSL - stdin is null");
     }
-    /**
-     * List directory contents in WSL
-     */
-    async listDirectory(path) {
-        if (!this.config) {
-            throw new Error('Not connected to WSL');
-        }
-        const distro = this.config.distribution.trim().replace(/\0/g, '');
-        const wslPath = this.resolveWSLPath(path);
-        const command = `wsl.exe -d ${distro} -- ls -la "${wslPath}"`;
-        try {
-            const { stdout } = await execAsync(command);
-            return this.parseDirectoryListing(stdout);
-        }
-        catch (error) {
-            throw new Error(`Failed to list directory ${path}: ${error.message}`);
-        }
+    if (this.shellProcess.killed || this.shellProcess.exitCode !== null) {
+      throw new SubshellExecutionError(command, "Not connected to WSL - shell process has exited");
     }
-    /**
-     * Search for files matching a pattern in WSL
-     */
-    async searchFiles(pattern, directory) {
-        if (!this.config) {
-            throw new Error('Not connected to WSL');
-        }
-        const distro = this.config.distribution.trim().replace(/\0/g, '');
-        const wslPath = this.resolveWSLPath(directory);
-        const escapedPattern = pattern.replace(/'/g, "'\\''");
-        const command = `wsl.exe -d ${distro} -- bash -c "grep -rn '${escapedPattern}' '${wslPath}' 2>/dev/null || true"`;
-        try {
-            const { stdout } = await execAsync(command);
-            return this.parseSearchResults(stdout);
-        }
-        catch (error) {
-            // grep returns non-zero if no matches, which is not an error
-            return [];
-        }
+    try {
+      this.currentOutput = "";
+      this.currentError = "";
+      const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
+      let commandWithPwd;
+      const trimmedCommand = command.trim();
+      if (trimmedCommand.startsWith("cd ") || trimmedCommand === "cd") {
+        commandWithPwd = `${command}; echo "${pwdTag}:$(pwd)"
+`;
+      } else {
+        commandWithPwd = `cd ${this.currentWorkingDirectory} && ${command}; echo "${pwdTag}:$(pwd)"
+`;
+      }
+      this.shellProcess.stdin.write(commandWithPwd);
+      const result = await this.waitForCommandCompletion(3e4);
+      return result;
+    } catch (error) {
+      return {
+        stdout: "",
+        stderr: error.message || "Command execution failed",
+        exitCode: 1
+      };
     }
-    /**
-     * Get the current working directory in WSL
-     */
-    async getCurrentWorkingDirectory() {
-        if (!this.config || !this.shellProcess || !this.shellProcess.stdin) {
-            return '~';
-        }
-        try {
-            // Clear output
-            this.currentOutput = '';
-            // Send pwd command
-            this.shellProcess.stdin.write('pwd\n');
-            // Wait for output
-            await new Promise(resolve => setTimeout(resolve, 300));
-            const lines = this.currentOutput.trim().split('\n');
-            const path = lines[lines.length - 1].trim();
-            return path || '~';
-        }
-        catch {
-            return '~';
-        }
+  }
+  /**
+   * Wait for command completion by monitoring output
+   */
+  async waitForCommandCompletion(timeoutMs = 3e4) {
+    const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
+    const pwdRegex = new RegExp(`${pwdTag}:(.+)$`, "m");
+    const removeRegex = new RegExp(`${pwdTag}:.+$`, "m");
+    return new Promise((resolve, reject) => {
+      const startTime = Date.now();
+      const checkInterval = setInterval(() => {
+        if (timeoutMs > 0 && Date.now() - startTime >= timeoutMs) {
+          clearInterval(checkInterval);
+          reject(new Error(`Command execution timed out after ${timeoutMs}ms`));
+          return;
+        }
+        const pwdMatch = this.currentOutput.match(pwdRegex);
+        if (pwdMatch) {
+          clearInterval(checkInterval);
+          const newCwd = pwdMatch[1].trim();
+          this.currentWorkingDirectory = newCwd;
+          const cleanStdout = this.currentOutput.replace(removeRegex, "").trim();
+          resolve({
+            stdout: cleanStdout,
+            stderr: this.currentError,
+            exitCode: 0
+          });
+        }
+      }, 100);
+    });
+  }
+  /**
+   * Read a file from the WSL filesystem
+   */
+  async readFile(path) {
+    if (!this.config) {
+      throw new Error("Not connected to WSL");
     }
-    /**
-     * Get the shell type
-     */
-    async getShellType() {
-        return this.shellType;
-    }
-    /**
-     * Get the operating system type (always linux for WSL)
-     */
-    async getOSType() {
-        return 'linux';
-    }
-    /**
-     * Get breadcrumb information for the UI
-     */
-    getBreadcrumbs() {
-        if (!this.config) {
-            return [];
-        }
-        return [
-            {
-                label: 'wsl',
-                color: 'yellow',
-            },
-            {
-                label: this.config.distribution,
-                color: 'yellow',
-            },
-        ];
-    }
-    // Private helper methods
-    /**
-     * Verify that WSL is available on the system
-     */
-    verifyWSLAvailable() {
-        if (os.platform() !== 'win32') {
-            throw new Error('WSL is only available on Windows');
-        }
+    const distro = this.config.distribution.trim().replace(/\0/g, "");
+    const wslPath = this.resolveWSLPath(path);
+    const command = `wsl.exe -d ${distro} -- bash -c "base64 '${wslPath}' 2>/dev/null || cat '${wslPath}' | base64"`;
+    try {
+      const { stdout } = await execAsync(command);
+      const b64 = stdout.replace(/\s+/g, "");
+      return Buffer.from(b64, "base64").toString("utf-8");
+    } catch (error) {
+      throw new Error(`Failed to read file ${path}: ${error.message}`);
     }
-    /**
-     * Parse WSL command to extract distribution name
-     */
-    async parseWSLCommand(command) {
-        const parts = command.trim().split(/\s+/);
-        let distribution = '';
-        // Look for -d or --distribution flag
-        for (let i = 1; i < parts.length; i++) {
-            const part = parts[i];
-            if ((part === '-d' || part === '--distribution') && i + 1 < parts.length) {
-                distribution = parts[i + 1];
-                break;
-            }
-        }
-        // If no distribution specified, get the default
-        if (!distribution) {
-            distribution = await this.getDefaultDistribution();
-        }
-        return {
-            distribution,
-        };
-    }
-    /**
-     * Get the default WSL distribution
-     */
-    async getDefaultDistribution() {
-        try {
-            const { stdout } = await execAsync('wsl.exe --list --verbose');
-            // Remove BOM and null bytes from output
-            const cleanOutput = stdout.replace(/^\uFEFF/, '').replace(/\0/g, '');
-            const lines = cleanOutput.split('\n');
-            // Find the line with * (default distribution)
-            for (const line of lines) {
-                if (line.includes('*')) {
-                    const match = line.match(/\*\s+(\S+)/);
-                    if (match) {
-                        const distro = match[1].trim().replace(/\0/g, '');
-                        if (distro) {
-                            return distro;
-                        }
-                    }
-                }
-            }
-            // If no default found, return the first distribution
-            for (const line of lines) {
-                const match = line.match(/^\s+(\S+)/);
-                if (match && !match[1].includes('NAME')) {
-                    const distro = match[1].trim().replace(/\0/g, '');
-                    if (distro) {
-                        return distro;
-                    }
-                }
-            }
-            throw new Error('No WSL distributions found');
-        }
-        catch (error) {
-            throw new Error('Failed to detect WSL distribution');
-        }
+  }
+  /**
+   * Write a file to the WSL filesystem
+   */
+  async writeFile(path, content) {
+    if (!this.config) {
+      throw new Error("Not connected to WSL");
     }
-    /**
-     * Detect the shell type in WSL
-     */
-    async detectShellType() {
-        if (!this.config || !this.shellProcess || !this.shellProcess.stdin) {
-            return 'bash';
-        }
-        try {
-            // Clear output
-            this.currentOutput = '';
-            // Send command to detect shell
-            this.shellProcess.stdin.write('echo $SHELL\n');
-            // Wait for output
-            await new Promise(resolve => setTimeout(resolve, 300));
-            const shellPath = this.currentOutput.trim();
-            if (shellPath.includes('bash'))
-                return 'bash';
-            if (shellPath.includes('zsh'))
-                return 'zsh';
-            if (shellPath.includes('fish'))
-                return 'fish';
-            return 'bash';
-        }
-        catch {
-            return 'bash';
-        }
+    const distro = this.config.distribution.trim().replace(/\0/g, "");
+    const wslPath = this.resolveWSLPath(path);
+    const inputBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+    const base64Content = inputBuffer.toString("base64");
+    const CHUNK_SIZE = 32e3;
+    try {
+      const truncateCmd = `wsl.exe -d ${distro} -- bash -c ": > '${wslPath}'"`;
+      await execAsync(truncateCmd);
+      for (let i = 0; i < base64Content.length; i += CHUNK_SIZE) {
+        const chunk = base64Content.slice(i, i + CHUNK_SIZE);
+        const writeCmd = `wsl.exe -d ${distro} -- bash -c "echo '${chunk}' | base64 -d >> '${wslPath}'"`;
+        await execAsync(writeCmd);
+      }
+    } catch (error) {
+      throw new Error(`Failed to write file ${path}: ${error.message}`);
     }
-    /**
-     * Build a WSL command with working directory context
-     */
-    buildWSLCommand(command) {
-        if (!this.config) {
-            throw new Error('Not connected to WSL');
-        }
-        // Validate distribution name
-        const distro = this.config.distribution.trim().replace(/\0/g, '');
-        if (!distro) {
-            throw new Error('Invalid WSL distribution name');
-        }
-        // Determine the directory to cd into
-        const targetDir = this.currentWorkingDirectory === '~' || this.currentWorkingDirectory === ''
-            ? '~'
-            : this.currentWorkingDirectory;
-        // Unique PWD tag
-        const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
-        // Build the command with pwd tracking
-        // Use single quotes to avoid escaping issues with $
-        const bashScript = `cd ${targetDir} && ${command}; echo "${pwdTag}:$(pwd)"`;
-        // Use wsl.exe with bash -c and single quotes
-        return `wsl.exe -d ${distro} -- bash -c '${bashScript.replace(/'/g, "'\\''")}'`;
-    }
-    /**
-     * Convert Windows path to WSL path
-     */
-    static windowsToWSLPath(windowsPath) {
-        // Convert C:\Users\... to /mnt/c/Users/...
-        const match = windowsPath.match(/^([A-Za-z]):(\\|\/)/);
-        if (match) {
-            const drive = match[1].toLowerCase();
-            const rest = windowsPath.substring(2).replace(/\\/g, '/');
-            return `/mnt/${drive}${rest}`;
-        }
-        // Already a Unix path
-        return windowsPath.replace(/\\/g, '/');
-    }
-    /**
-     * Convert WSL path to Windows path
-     */
-    static wslToWindowsPath(wslPath) {
-        // Convert /mnt/c/Users/... to C:\Users\...
-        const match = wslPath.match(/^\/mnt\/([a-z])(\/.*)?$/);
-        if (match) {
-            const drive = match[1].toUpperCase();
-            const rest = (match[2] || '').replace(/\//g, '\\');
-            return `${drive}:${rest}`;
-        }
-        // Not a /mnt path, return as-is
-        return wslPath;
-    }
-    /**
-     * Resolve a path to a WSL path
-     */
-    resolveWSLPath(path) {
-        // If it's already an absolute Unix path, use it
-        if (path.startsWith('/')) {
-            return path;
-        }
-        // If it starts with ~, use it
-        if (path.startsWith('~')) {
-            return path;
-        }
-        // If it's a Windows path, convert it
-        if (path.match(/^[A-Za-z]:/)) {
-            return WSLHandler.windowsToWSLPath(path);
-        }
-        // Otherwise, treat as relative to current working directory
-        return `${this.currentWorkingDirectory}/${path}`;
-    }
-    /**
-     * Parse directory listing output
-     */
-    parseDirectoryListing(output) {
-        const entries = [];
-        const lines = output.split('\n').filter(line => line.trim());
-        for (const line of lines) {
-            // Skip total line and current/parent directory
-            if (line.startsWith('total') || line.endsWith(' .') || line.endsWith(' ..')) {
-                continue;
-            }
-            // Parse ls -la output: permissions links owner group size date time name
-            const match = line.match(/^([drwx-]+)\s+\d+\s+\S+\s+\S+\s+(\d+)\s+\S+\s+\S+\s+\S+\s+(.+)$/);
-            if (match) {
-                const permissions = match[1];
-                const size = parseInt(match[2], 10);
-                const name = match[3];
-                entries.push({
-                    name,
-                    type: permissions.startsWith('d') ? 'directory' : 'file',
-                    size,
-                    permissions,
-                });
-            }
-        }
-        return entries;
-    }
-    /**
-     * Parse search results from grep output
-     */
-    parseSearchResults(output) {
-        const results = [];
-        const lines = output.split('\n').filter(line => line.trim());
-        for (const line of lines) {
-            const match = line.match(/^(.+?):(\d+):(.+)$/);
-            if (match) {
-                results.push({
-                    file: match[1],
-                    line: parseInt(match[2], 10),
-                    content: match[3],
-                });
+  }
+  /**
+   * List directory contents in WSL
+   */
+  async listDirectory(path) {
+    if (!this.config) {
+      throw new Error("Not connected to WSL");
+    }
+    const distro = this.config.distribution.trim().replace(/\0/g, "");
+    const wslPath = this.resolveWSLPath(path);
+    const command = `wsl.exe -d ${distro} -- ls -la "${wslPath}"`;
+    try {
+      const { stdout } = await execAsync(command);
+      return this.parseDirectoryListing(stdout);
+    } catch (error) {
+      throw new Error(`Failed to list directory ${path}: ${error.message}`);
+    }
+  }
+  /**
+   * Search for files matching a pattern in WSL
+   */
+  async searchFiles(pattern, directory) {
+    if (!this.config) {
+      throw new Error("Not connected to WSL");
+    }
+    const distro = this.config.distribution.trim().replace(/\0/g, "");
+    const wslPath = this.resolveWSLPath(directory);
+    const escapedPattern = pattern.replace(/'/g, "'\\''");
+    const command = `wsl.exe -d ${distro} -- bash -c "grep -rn '${escapedPattern}' '${wslPath}' 2>/dev/null || true"`;
+    try {
+      const { stdout } = await execAsync(command);
+      return this.parseSearchResults(stdout);
+    } catch (error) {
+      return [];
+    }
+  }
+  /**
+   * Get the current working directory in WSL
+   */
+  async getCurrentWorkingDirectory() {
+    if (!this.config || !this.shellProcess || !this.shellProcess.stdin) {
+      return "~";
+    }
+    try {
+      this.currentOutput = "";
+      this.shellProcess.stdin.write("pwd\n");
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const lines = this.currentOutput.trim().split("\n");
+      const path = lines[lines.length - 1].trim();
+      return path || "~";
+    } catch {
+      return "~";
+    }
+  }
+  /**
+   * Get the shell type
+   */
+  async getShellType() {
+    return this.shellType;
+  }
+  /**
+   * Get the operating system type (always linux for WSL)
+   */
+  async getOSType() {
+    return "linux";
+  }
+  /**
+   * Get breadcrumb information for the UI
+   */
+  getBreadcrumbs() {
+    if (!this.config) {
+      return [];
+    }
+    return [
+      {
+        label: "wsl",
+        color: "yellow"
+      },
+      {
+        label: this.config.distribution,
+        color: "yellow"
+      }
+    ];
+  }
+  // Private helper methods
+  /**
+   * Verify that WSL is available on the system
+   */
+  verifyWSLAvailable() {
+    if (os.platform() !== "win32") {
+      throw new Error("WSL is only available on Windows");
+    }
+  }
+  /**
+   * Parse WSL command to extract distribution name
+   */
+  async parseWSLCommand(command) {
+    const parts = command.trim().split(/\s+/);
+    let distribution = "";
+    for (let i = 1; i < parts.length; i++) {
+      const part = parts[i];
+      if ((part === "-d" || part === "--distribution") && i + 1 < parts.length) {
+        distribution = parts[i + 1];
+        break;
+      }
+    }
+    if (!distribution) {
+      distribution = await this.getDefaultDistribution();
+    }
+    return {
+      distribution
+    };
+  }
+  /**
+   * Get the default WSL distribution
+   */
+  async getDefaultDistribution() {
+    try {
+      const { stdout } = await execAsync("wsl.exe --list --verbose");
+      const cleanOutput = stdout.replace(/^\uFEFF/, "").replace(/\0/g, "");
+      const lines = cleanOutput.split("\n");
+      for (const line of lines) {
+        if (line.includes("*")) {
+          const match = line.match(/\*\s+(\S+)/);
+          if (match) {
+            const distro = match[1].trim().replace(/\0/g, "");
+            if (distro) {
+              return distro;
             }
-        }
-        return results;
-    }
-    /**
-     * Execute a promise with a timeout
-     */
-    async executeWithTimeout(operation, timeoutMs, operationName) {
-        return Promise.race([
-            operation(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`${operationName} timed out after ${timeoutMs}ms`)), timeoutMs)),
-        ]);
-    }
-    /**
-     * Create a new instance of this handler
-     */
-    createNew() {
-        const newHandler = new WSLHandler();
-        if (this.onOutputCallback) {
-            newHandler.setOutputCallback(this.onOutputCallback);
-        }
-        return newHandler;
+          }
+        }
+      }
+      for (const line of lines) {
+        const match = line.match(/^\s+(\S+)/);
+        if (match && !match[1].includes("NAME")) {
+          const distro = match[1].trim().replace(/\0/g, "");
+          if (distro) {
+            return distro;
+          }
+        }
+      }
+      throw new Error("No WSL distributions found");
+    } catch (error) {
+      throw new Error("Failed to detect WSL distribution");
+    }
+  }
+  /**
+   * Detect the shell type in WSL
+   */
+  async detectShellType() {
+    if (!this.config || !this.shellProcess || !this.shellProcess.stdin) {
+      return "bash";
+    }
+    try {
+      this.currentOutput = "";
+      this.shellProcess.stdin.write("echo $SHELL\n");
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      const shellPath = this.currentOutput.trim();
+      if (shellPath.includes("bash")) return "bash";
+      if (shellPath.includes("zsh")) return "zsh";
+      if (shellPath.includes("fish")) return "fish";
+      return "bash";
+    } catch {
+      return "bash";
+    }
+  }
+  /**
+   * Build a WSL command with working directory context
+   */
+  buildWSLCommand(command) {
+    if (!this.config) {
+      throw new Error("Not connected to WSL");
+    }
+    const distro = this.config.distribution.trim().replace(/\0/g, "");
+    if (!distro) {
+      throw new Error("Invalid WSL distribution name");
+    }
+    const targetDir = this.currentWorkingDirectory === "~" || this.currentWorkingDirectory === "" ? "~" : this.currentWorkingDirectory;
+    const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
+    const bashScript = `cd ${targetDir} && ${command}; echo "${pwdTag}:$(pwd)"`;
+    return `wsl.exe -d ${distro} -- bash -c '${bashScript.replace(/'/g, "'\\''")}'`;
+  }
+  /**
+   * Convert Windows path to WSL path
+   */
+  static windowsToWSLPath(windowsPath) {
+    const match = windowsPath.match(/^([A-Za-z]):(\\|\/)/);
+    if (match) {
+      const drive = match[1].toLowerCase();
+      const rest = windowsPath.substring(2).replace(/\\/g, "/");
+      return `/mnt/${drive}${rest}`;
+    }
+    return windowsPath.replace(/\\/g, "/");
+  }
+  /**
+   * Convert WSL path to Windows path
+   */
+  static wslToWindowsPath(wslPath) {
+    const match = wslPath.match(/^\/mnt\/([a-z])(\/.*)?$/);
+    if (match) {
+      const drive = match[1].toUpperCase();
+      const rest = (match[2] || "").replace(/\//g, "\\");
+      return `${drive}:${rest}`;
+    }
+    return wslPath;
+  }
+  /**
+   * Resolve a path to a WSL path
+   */
+  resolveWSLPath(path) {
+    if (path.startsWith("/")) {
+      return path;
+    }
+    if (path.startsWith("~")) {
+      return path;
+    }
+    if (path.match(/^[A-Za-z]:/)) {
+      return WSLHandler.windowsToWSLPath(path);
+    }
+    return `${this.currentWorkingDirectory}/${path}`;
+  }
+  /**
+   * Parse directory listing output
+   */
+  parseDirectoryListing(output) {
+    const entries = [];
+    const lines = output.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      if (line.startsWith("total") || line.endsWith(" .") || line.endsWith(" ..")) {
+        continue;
+      }
+      const match = line.match(/^([drwx-]+)\s+\d+\s+\S+\s+\S+\s+(\d+)\s+\S+\s+\S+\s+\S+\s+(.+)$/);
+      if (match) {
+        const permissions = match[1];
+        const size = parseInt(match[2], 10);
+        const name = match[3];
+        entries.push({
+          name,
+          type: permissions.startsWith("d") ? "directory" : "file",
+          size,
+          permissions
+        });
+      }
+    }
+    return entries;
+  }
+  /**
+   * Parse search results from grep output
+   */
+  parseSearchResults(output) {
+    const results = [];
+    const lines = output.split("\n").filter((line) => line.trim());
+    for (const line of lines) {
+      const match = line.match(/^(.+?):(\d+):(.+)$/);
+      if (match) {
+        results.push({
+          file: match[1],
+          line: parseInt(match[2], 10),
+          content: match[3]
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Execute a promise with a timeout
+   */
+  async executeWithTimeout(operation, timeoutMs, operationName) {
+    return Promise.race([
+      operation(),
+      new Promise(
+        (_, reject) => setTimeout(
+          () => reject(new Error(`${operationName} timed out after ${timeoutMs}ms`)),
+          timeoutMs
+        )
+      )
+    ]);
+  }
+  /**
+   * Create a new instance of this handler
+   */
+  createNew() {
+    const newHandler = new WSLHandler();
+    if (this.onOutputCallback) {
+      newHandler.setOutputCallback(this.onOutputCallback);
     }
+    return newHandler;
+  }
 }
+export {
+  WSLHandler
+};
 //# sourceMappingURL=wsl-handler.js.map