centaurus-cli 3.0.1 → 3.1.0

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

@@ -1,607 +1,549 @@
-/**
- * Docker Handler for container execution
- */
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { writeFile, unlink } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { SubshellConnectionError, SubshellExecutionError } from '../types.js';
-import { randomBytes } from 'crypto';
-import { quickLog } from '../../utils/conversation-logger.js';
+import { exec } from "child_process";
+import { promisify } from "util";
+import { writeFile, unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { SubshellConnectionError, SubshellExecutionError } from "../types.js";
+import { randomBytes } from "crypto";
+import { quickLog } from "../../utils/conversation-logger.js";
 const execAsync = promisify(exec);
-/**
- * Docker Handler implementation
- */
-export class DockerHandler {
-    type = 'docker';
-    detectionPatterns = [
-        /^docker\s+exec\s+/,
-        /^docker\s+exec\s+-it\s+/,
-    ];
-    config = null;
-    currentWorkingDirectory = '/';
-    shellType = 'sh';
-    osType = 'linux';
-    sessionId = '';
-    parentContext; // For nested connections
-    /**
-     * Detect if a command should trigger this handler
-     */
-    detect(command) {
-        return this.detectionPatterns.some(pattern => pattern.test(command));
+class DockerHandler {
+  type = "docker";
+  detectionPatterns = [
+    /^docker\s+exec\s+/,
+    /^docker\s+exec\s+-it\s+/
+  ];
+  config = null;
+  currentWorkingDirectory = "/";
+  shellType = "sh";
+  osType = "linux";
+  sessionId = "";
+  parentContext;
+  // For nested connections
+  /**
+   * Detect if a command should trigger this handler
+   */
+  detect(command) {
+    return this.detectionPatterns.some((pattern) => pattern.test(command));
+  }
+  /**
+   * Connect to the Docker container
+   */
+  async connect(command, cwd) {
+    this.sessionId = randomBytes(16).toString("hex");
+    try {
+      this.config = this.parseDockerCommand(command);
+      await this.verifyContainer();
+      this.shellType = await this.detectShellType();
+      this.osType = await this.detectOSType();
+      this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
+      return {
+        type: "docker",
+        handler: this,
+        metadata: {
+          workingDirectory: this.currentWorkingDirectory,
+          shell: this.shellType,
+          os: this.osType,
+          containerId: this.config.containerId
+        },
+        connectionState: "connected",
+        sessionId: this.sessionId
+      };
+    } catch (error) {
+      throw new SubshellConnectionError(
+        "docker",
+        error instanceof Error ? error.message : "Unknown error",
+        false
+      );
     }
-    /**
-     * Connect to the Docker container
-     */
-    async connect(command, cwd) {
-        this.sessionId = randomBytes(16).toString('hex');
+  }
+  /**
+   * Connect from an existing remote context (nested session)
+   */
+  async connectFromRemote(command, cwd, parentContext) {
+    this.sessionId = randomBytes(16).toString("hex");
+    this.parentContext = parentContext;
+    try {
+      this.config = this.parseDockerCommand(command);
+      try {
+        await this.verifyContainer();
+        const result = await this.executeCommand("echo verification");
+        if (result.exitCode !== 0 || result.stderr && (result.stderr.includes("npipe:") || result.stderr.includes("pipe/docker"))) {
+          quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] Remote Docker execution failed, attempting local fallback. Error: ${result.stderr || "exit code " + result.exitCode}
+`);
+          throw new Error(`Docker execution failed remotely: ${result.stderr || "exit code " + result.exitCode}`);
+        }
+        quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] Successfully verified Docker execution via remote context
+`);
+      } catch (remoteError) {
+        quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] Attempting local fallback for Docker execution
+`);
+        const originalParent = this.parentContext;
+        this.parentContext = void 0;
         try {
-            // Parse Docker command to extract container ID
-            this.config = this.parseDockerCommand(command);
-            // Verify container exists and is running
-            await this.verifyContainer();
-            // Detect shell type and OS
-            this.shellType = await this.detectShellType();
-            this.osType = await this.detectOSType();
-            // Get initial working directory
-            this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
-            return {
-                type: 'docker',
-                handler: this,
-                metadata: {
-                    workingDirectory: this.currentWorkingDirectory,
-                    shell: this.shellType,
-                    os: this.osType,
-                    containerId: this.config.containerId,
-                },
-                connectionState: 'connected',
-                sessionId: this.sessionId,
-            };
-        }
-        catch (error) {
-            throw new SubshellConnectionError('docker', error instanceof Error ? error.message : 'Unknown error', false);
-        }
+          await this.verifyContainer();
+          const localResult = await this.executeCommand("echo verification");
+          if (localResult.exitCode !== 0 || localResult.stderr && (localResult.stderr.includes("npipe:") || localResult.stderr.includes("pipe/docker"))) {
+            throw new Error(`Local Docker execution also failed: ${localResult.stderr || "exit code " + localResult.exitCode}`);
+          }
+          quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] Successfully fell back to local Docker execution (parentContext cleared)
+`);
+        } catch (localError) {
+          quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] Local fallback also failed, restoring remote context
+`);
+          this.parentContext = originalParent;
+          throw remoteError;
+        }
+      }
+      this.shellType = await this.detectShellType();
+      this.osType = await this.detectOSType();
+      this.currentWorkingDirectory = "";
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] Reset currentWorkingDirectory, calling getCurrentWorkingDirectory()
+`);
+      this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] After getCurrentWorkingDirectory, currentWorkingDirectory=${this.currentWorkingDirectory}
+`);
+      return {
+        type: "docker",
+        handler: this,
+        metadata: {
+          workingDirectory: this.currentWorkingDirectory,
+          shell: this.shellType,
+          os: this.osType,
+          containerId: this.config.containerId
+        },
+        connectionState: "connected",
+        sessionId: this.sessionId
+      };
+    } catch (error) {
+      this.parentContext = void 0;
+      throw new SubshellConnectionError(
+        "docker",
+        error instanceof Error ? error.message : "Unknown error",
+        false
+      );
+    }
+  }
+  /**
+   * Disconnect from the Docker container
+   */
+  async disconnect() {
+    this.config = null;
+  }
+  /**
+   * Check if this handler is currently connected to a Docker container
+   */
+  isConnected() {
+    return this.config !== null;
+  }
+  /**
+   * Execute a command in the Docker container
+   */
+  async executeCommand(command) {
+    if (!this.config) {
+      throw new SubshellExecutionError(command, "Not connected to Docker container");
     }
-    /**
-     * Connect from an existing remote context (nested session)
-     */
-    async connectFromRemote(command, cwd, parentContext) {
-        this.sessionId = randomBytes(16).toString('hex');
-        this.parentContext = parentContext;
+    const isCdCommand = /^\s*cd\s+/.test(command) || command.trim() === "cd";
+    const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
+    try {
+      const oldCwd = this.currentWorkingDirectory || "/";
+      const dockerCommand = this.buildDockerCommand(command, pwdTag);
+      const { stdout, stderr } = await this.executeWithTimeout(
+        () => this.executeHostCommand(dockerCommand),
+        3e4,
+        "Command execution"
+      );
+      const pwdRegex = new RegExp(`${pwdTag}:(.+)$`, "m");
+      const pwdMatch = stdout.match(pwdRegex);
+      let cleanStdout = stdout;
+      if (pwdMatch) {
+        const extractedPwd = pwdMatch[1].trim();
+        quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] executeCommand extracted CWD from output: "${extractedPwd}"
+`);
+        this.currentWorkingDirectory = extractedPwd;
+        const removeRegex = new RegExp(`${pwdTag}:.+$`, "m");
+        cleanStdout = stdout.replace(removeRegex, "").trim();
+      }
+      if (isCdCommand) {
         try {
-            // Parse Docker command to extract container ID
-            this.config = this.parseDockerCommand(command);
-            // Verify container exists AND we can execute commands
-            // A simple 'docker inspect' might succeed remotely via SSH metadata service,
-            // but 'docker exec' might fail due to stream/pipe issues (the npipe error).
-            // We must verify actual execution capability.
-            try {
-                await this.verifyContainer();
-                // Also verify we can actually run a command
-                const result = await this.executeCommand('echo verification');
-                // Check if the result indicates Docker pipe errors (exitCode != 0 or stderr contains pipe errors)
-                if (result.exitCode !== 0 || (result.stderr && (result.stderr.includes('npipe:') || result.stderr.includes('pipe/docker')))) {
-                    quickLog(`[${new Date().toISOString()}] [DockerHandler] Remote Docker execution failed, attempting local fallback. Error: ${result.stderr || 'exit code ' + result.exitCode}\n`);
-                    throw new Error(`Docker execution failed remotely: ${result.stderr || 'exit code ' + result.exitCode}`);
-                }
-                quickLog(`[${new Date().toISOString()}] [DockerHandler] Successfully verified Docker execution via remote context\n`);
-            }
-            catch (remoteError) {
-                // Fallback: If remote execution fails, try local execution
-                // This handles scenarios like SSH-ing to localhost where Docker pipes aren't accessible remotely
-                // but are accessible locally.
-                quickLog(`[${new Date().toISOString()}] [DockerHandler] Attempting local fallback for Docker execution\n`);
-                const originalParent = this.parentContext;
-                this.parentContext = undefined; // Temporarily switch to local
-                try {
-                    await this.verifyContainer();
-                    // Also verify we can execute commands locally
-                    const localResult = await this.executeCommand('echo verification');
-                    if (localResult.exitCode !== 0 || (localResult.stderr && (localResult.stderr.includes('npipe:') || localResult.stderr.includes('pipe/docker')))) {
-                        throw new Error(`Local Docker execution also failed: ${localResult.stderr || 'exit code ' + localResult.exitCode}`);
-                    }
-                    // If successful, keep parentContext as undefined (permanent fallback to local)
-                    // Note: We'll get the proper CWD later via getCurrentWorkingDirectory()
-                    quickLog(`[${new Date().toISOString()}] [DockerHandler] Successfully fell back to local Docker execution (parentContext cleared)\n`);
-                }
-                catch (localError) {
-                    // If local also fails, restore parent context and throw original remote error
-                    quickLog(`[${new Date().toISOString()}] [DockerHandler] Local fallback also failed, restoring remote context\n`);
-                    this.parentContext = originalParent;
-                    throw remoteError;
-                }
-            }
-            // Detect shell type and OS
-            this.shellType = await this.detectShellType();
-            this.osType = await this.detectOSType();
-            // Get initial working directory - reset first to force fresh detection
-            // The verification command may have polluted currentWorkingDirectory via __CENTAURUS_PWD__ extraction
-            // which can have incorrect values due to SSH shell evaluation
-            this.currentWorkingDirectory = '';
-            quickLog(`[${new Date().toISOString()}] [DockerHandler] Reset currentWorkingDirectory, calling getCurrentWorkingDirectory()\n`);
-            this.currentWorkingDirectory = await this.getCurrentWorkingDirectory();
-            quickLog(`[${new Date().toISOString()}] [DockerHandler] After getCurrentWorkingDirectory, currentWorkingDirectory=${this.currentWorkingDirectory}\n`);
-            return {
-                type: 'docker',
-                handler: this,
-                metadata: {
-                    workingDirectory: this.currentWorkingDirectory,
-                    shell: this.shellType,
-                    os: this.osType,
-                    containerId: this.config.containerId,
-                },
-                connectionState: 'connected',
-                sessionId: this.sessionId,
-            };
-        }
-        catch (error) {
-            this.parentContext = undefined; // Reset on failure
-            throw new SubshellConnectionError('docker', error instanceof Error ? error.message : 'Unknown error', false);
-        }
+          const escapedOldCwd = oldCwd.replace(/"/g, '\\"');
+          const escapedCommand = command.replace(/"/g, '\\"');
+          const pwdCommand = `docker exec ${this.config.containerId} sh -c "cd \\"${escapedOldCwd}\\" && ${escapedCommand} && pwd"`;
+          quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] cd verification command: ${pwdCommand}
+`);
+          const { stdout: pwdOutput } = await this.executeHostCommand(pwdCommand);
+          const actualCwd = pwdOutput.trim();
+          if (actualCwd && actualCwd.startsWith("/")) {
+            quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] cd command: verified CWD is "${actualCwd}"
+`);
+            this.currentWorkingDirectory = actualCwd;
+          }
+        } catch (pwdError) {
+          quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DockerHandler] cd command: pwd verification failed, keeping extracted value
+`);
+        }
+      }
+      return {
+        stdout: cleanStdout,
+        stderr,
+        exitCode: 0
+      };
+    } catch (error) {
+      return {
+        stdout: "",
+        stderr: error.stderr || error.message,
+        exitCode: error.code || 1
+      };
     }
-    /**
-     * Disconnect from the Docker container
-     */
-    async disconnect() {
-        this.config = null;
+  }
+  /**
+   * Read a file from the Docker container filesystem
+   */
+  async readFile(path) {
+    if (!this.config) {
+      throw new Error("Not connected to Docker container");
     }
-    /**
-     * Check if this handler is currently connected to a Docker container
-     */
-    isConnected() {
-        return this.config !== null;
+    const absolutePath = this.resolveAbsolutePath(path);
+    const command = `docker exec ${this.config.containerId} sh -lc "base64 '${absolutePath}' 2>/dev/null || cat '${absolutePath}' | base64"`;
+    try {
+      const { stdout } = await this.executeHostCommand(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}`);
     }
-    /**
-     * Execute a command in the Docker container
-     */
-    async executeCommand(command) {
-        if (!this.config) {
-            throw new SubshellExecutionError(command, 'Not connected to Docker container');
-        }
-        // Check if this is a cd command - we'll need special CWD handling
-        const isCdCommand = /^\s*cd\s+/.test(command) || command.trim() === 'cd';
-        // Use unique PWD tag
-        const pwdTag = `__CENTAURUS_PWD_${this.sessionId}__`;
-        try {
-            // Store old CWD before execution for cd verification
-            const oldCwd = this.currentWorkingDirectory || '/';
-            const dockerCommand = this.buildDockerCommand(command, pwdTag);
-            const { stdout, stderr } = await this.executeWithTimeout(() => this.executeHostCommand(dockerCommand), 30000, 'Command execution');
-            // Extract working directory from output using unique tag
-            // We use a constructed regex to match the specific tag for this session
-            const pwdRegex = new RegExp(`${pwdTag}:(.+)$`, 'm');
-            const pwdMatch = stdout.match(pwdRegex);
-            let cleanStdout = stdout;
-            if (pwdMatch) {
-                const extractedPwd = pwdMatch[1].trim();
-                quickLog(`[${new Date().toISOString()}] [DockerHandler] executeCommand extracted CWD from output: "${extractedPwd}"\n`);
-                this.currentWorkingDirectory = extractedPwd;
-                // Remove the tag line from stdout
-                const removeRegex = new RegExp(`${pwdTag}:.+$`, 'm');
-                cleanStdout = stdout.replace(removeRegex, '').trim();
-            }
-            // For cd commands, the $(pwd) extraction through SSH can be unreliable
-            // due to shell evaluation issues. Run the cd command again with pwd to verify.
-            if (isCdCommand) {
-                try {
-                    // Run: cd <old_dir> && <user_cd_command> && pwd to get the actual new directory
-                    const escapedOldCwd = oldCwd.replace(/"/g, '\\"');
-                    const escapedCommand = command.replace(/"/g, '\\"');
-                    // For verification, we don't need the tag since we just want the output
-                    const pwdCommand = `docker exec ${this.config.containerId} sh -c "cd \\"${escapedOldCwd}\\" && ${escapedCommand} && pwd"`;
-                    quickLog(`[${new Date().toISOString()}] [DockerHandler] cd verification command: ${pwdCommand}\n`);
-                    const { stdout: pwdOutput } = await this.executeHostCommand(pwdCommand);
-                    const actualCwd = pwdOutput.trim();
-                    if (actualCwd && actualCwd.startsWith('/')) {
-                        quickLog(`[${new Date().toISOString()}] [DockerHandler] cd command: verified CWD is "${actualCwd}"\n`);
-                        this.currentWorkingDirectory = actualCwd;
-                    }
-                }
-                catch (pwdError) {
-                    // If pwd verification fails, keep the extracted value
-                    quickLog(`[${new Date().toISOString()}] [DockerHandler] cd command: pwd verification failed, keeping extracted value\n`);
-                }
-            }
-            return {
-                stdout: cleanStdout,
-                stderr,
-                exitCode: 0,
-            };
-        }
-        catch (error) {
-            return {
-                stdout: '',
-                stderr: error.stderr || error.message,
-                exitCode: error.code || 1,
-            };
-        }
+  }
+  /**
+   * Write a file to the Docker container filesystem
+   */
+  async writeFile(path, content) {
+    if (!this.config) {
+      throw new Error("Not connected to Docker container");
     }
-    /**
-     * Read a file from the Docker container filesystem
-     */
-    async readFile(path) {
-        if (!this.config) {
-            throw new Error('Not connected to Docker container');
-        }
-        const absolutePath = this.resolveAbsolutePath(path);
-        // Use base64 to avoid encoding issues and be binary-safe
-        const command = `docker exec ${this.config.containerId} sh -lc "base64 '${absolutePath}' 2>/dev/null || cat '${absolutePath}' | base64"`;
+    const absolutePath = this.resolveAbsolutePath(path);
+    const tempFile = join(tmpdir(), `centaurus-${randomBytes(8).toString("hex")}.tmp`);
+    try {
+      if (this.parentContext) {
+        throw new Error("Remote parent: forcing fallback");
+      }
+      if (Buffer.isBuffer(content)) {
+        await writeFile(tempFile, content);
+      } else {
+        await writeFile(tempFile, content, "utf8");
+      }
+      const copyCommand = `docker cp "${tempFile}" ${this.config.containerId}:"${absolutePath}"`;
+      await execAsync(copyCommand);
+      await unlink(tempFile);
+    } catch (error) {
+      try {
+        await this.executeHostCommand(`docker exec ${this.config.containerId} sh -lc ": > "${absolutePath}""`);
+        const inputBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");
+        const base64Content = inputBuffer.toString("base64");
+        const CHUNK_SIZE = 32e3;
+        for (let i = 0; i < base64Content.length; i += CHUNK_SIZE) {
+          const chunk = base64Content.slice(i, i + CHUNK_SIZE);
+          const writeCmd = `docker exec ${this.config.containerId} sh -lc 'echo "${chunk}" | base64 -d >> "${absolutePath}"'`;
+          await this.executeHostCommand(writeCmd);
+        }
+      } catch (fbErr) {
         try {
-            const { stdout } = await this.executeHostCommand(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}`);
-        }
+          await unlink(tempFile);
+        } catch {
+        }
+        throw new Error(`Failed to write file ${path}: ${error.message}; fallback failed: ${fbErr.message}`);
+      }
+      try {
+        await unlink(tempFile);
+      } catch {
+      }
     }
-    /**
-     * Write a file to the Docker container filesystem
-     */
-    async writeFile(path, content) {
-        if (!this.config) {
-            throw new Error('Not connected to Docker container');
-        }
-        const absolutePath = this.resolveAbsolutePath(path);
-        // Create a temporary file on the host
-        const tempFile = join(tmpdir(), `centaurus-${randomBytes(8).toString('hex')}.tmp`);
-        try {
-            // If remote, skip direct file copy and force fallback
-            if (this.parentContext) {
-                throw new Error('Remote parent: forcing fallback');
-            }
-            // Write content to temp file
-            if (Buffer.isBuffer(content)) {
-                await writeFile(tempFile, content);
-            }
-            else {
-                await writeFile(tempFile, content, 'utf8');
-            }
-            // Copy temp file to container
-            const copyCommand = `docker cp \"${tempFile}\" ${this.config.containerId}:\"${absolutePath}\"`;
-            await execAsync(copyCommand);
-            // Clean up temp file
-            await unlink(tempFile);
-        }
-        catch (error) {
-            // Try base64-over-exec fallback if docker cp fails
-            try {
-                // Ensure file is empty first
-                await this.executeHostCommand(`docker exec ${this.config.containerId} sh -lc ": > \"${absolutePath}\""`);
-                const inputBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
-                const base64Content = inputBuffer.toString('base64');
-                const CHUNK_SIZE = 32000;
-                for (let i = 0; i < base64Content.length; i += CHUNK_SIZE) {
-                    const chunk = base64Content.slice(i, i + CHUNK_SIZE);
-                    const writeCmd = `docker exec ${this.config.containerId} sh -lc 'echo "${chunk}" | base64 -d >> \"${absolutePath}\"'`;
-                    await this.executeHostCommand(writeCmd);
-                }
-            }
-            catch (fbErr) {
-                // Try to clean up temp file even if fallback also failed
-                try {
-                    await unlink(tempFile);
-                }
-                catch { }
-                throw new Error(`Failed to write file ${path}: ${error.message}; fallback failed: ${fbErr.message}`);
-            }
-            // Try to clean up temp file even if copy failed originally
-            try {
-                await unlink(tempFile);
-            }
-            catch { }
-        }
+  }
+  /**
+   * List directory contents in Docker container
+   */
+  async listDirectory(path) {
+    if (!this.config) {
+      throw new Error("Not connected to Docker container");
     }
-    /**
-     * List directory contents in Docker container
-     */
-    async listDirectory(path) {
-        if (!this.config) {
-            throw new Error('Not connected to Docker container');
-        }
-        const absolutePath = this.resolveAbsolutePath(path);
-        const command = `docker exec ${this.config.containerId} ls -la "${absolutePath}"`;
-        try {
-            const { stdout } = await this.executeHostCommand(command);
-            return this.parseDirectoryListing(stdout);
-        }
-        catch (error) {
-            throw new Error(`Failed to list directory ${path}: ${error.message}`);
-        }
+    const absolutePath = this.resolveAbsolutePath(path);
+    const command = `docker exec ${this.config.containerId} ls -la "${absolutePath}"`;
+    try {
+      const { stdout } = await this.executeHostCommand(command);
+      return this.parseDirectoryListing(stdout);
+    } catch (error) {
+      throw new Error(`Failed to list directory ${path}: ${error.message}`);
     }
-    /**
-     * Search for files matching a pattern in Docker container
-     */
-    async searchFiles(pattern, directory) {
-        if (!this.config) {
-            throw new Error('Not connected to Docker container');
-        }
-        const absolutePath = this.resolveAbsolutePath(directory);
-        const escapedPattern = pattern.replace(/'/g, "'\\''");
-        const command = `docker exec ${this.config.containerId} sh -c "grep -rn '${escapedPattern}' '${absolutePath}' 2>/dev/null || true"`;
-        try {
-            const { stdout } = await this.executeHostCommand(command);
-            return this.parseSearchResults(stdout);
-        }
-        catch (error) {
-            // grep returns non-zero if no matches, which is not an error
-            return [];
-        }
+  }
+  /**
+   * Search for files matching a pattern in Docker container
+   */
+  async searchFiles(pattern, directory) {
+    if (!this.config) {
+      throw new Error("Not connected to Docker container");
     }
-    /**
-     * Get the current working directory in the Docker container
-     * For initial detection: runs pwd in the container
-     * For subsequent calls: returns the tracked CWD (since each docker exec is a new shell)
-     */
-    async getCurrentWorkingDirectory() {
-        // If we already have a tracked CWD, return it
-        // This handles the case where cd was used to change directories
-        if (this.currentWorkingDirectory) {
-            return this.currentWorkingDirectory;
-        }
-        // Initial detection: run pwd to get the container's default working directory
-        if (!this.config) {
-            return '/';
-        }
-        const command = `docker exec ${this.config.containerId} pwd`;
-        try {
-            const { stdout } = await this.executeHostCommand(command);
-            this.currentWorkingDirectory = stdout.trim() || '/';
-            return this.currentWorkingDirectory;
-        }
-        catch {
-            return '/';
-        }
+    const absolutePath = this.resolveAbsolutePath(directory);
+    const escapedPattern = pattern.replace(/'/g, "'\\''");
+    const command = `docker exec ${this.config.containerId} sh -c "grep -rn '${escapedPattern}' '${absolutePath}' 2>/dev/null || true"`;
+    try {
+      const { stdout } = await this.executeHostCommand(command);
+      return this.parseSearchResults(stdout);
+    } catch (error) {
+      return [];
     }
-    /**
-     * Get the shell type
-     */
-    async getShellType() {
-        return this.shellType;
+  }
+  /**
+   * Get the current working directory in the Docker container
+   * For initial detection: runs pwd in the container
+   * For subsequent calls: returns the tracked CWD (since each docker exec is a new shell)
+   */
+  async getCurrentWorkingDirectory() {
+    if (this.currentWorkingDirectory) {
+      return this.currentWorkingDirectory;
     }
-    /**
-     * Get the operating system type
-     */
-    async getOSType() {
-        return this.osType;
+    if (!this.config) {
+      return "/";
     }
-    /**
-     * Get breadcrumb information for the UI
-     */
-    getBreadcrumbs() {
-        if (!this.config) {
-            return [];
-        }
-        const displayName = this.config.containerName || this.config.containerId.substring(0, 12);
-        return [
-            {
-                label: 'docker',
-                color: 'blue',
-            },
-            {
-                label: displayName,
-                color: 'blue',
-            },
-        ];
+    const command = `docker exec ${this.config.containerId} pwd`;
+    try {
+      const { stdout } = await this.executeHostCommand(command);
+      this.currentWorkingDirectory = stdout.trim() || "/";
+      return this.currentWorkingDirectory;
+    } catch {
+      return "/";
     }
-    // Private helper methods
-    /**
-     * Parse Docker exec command to extract container ID
-     */
-    parseDockerCommand(command) {
-        const parts = command.trim().split(/\s+/);
-        let containerId = '';
-        // Find the container ID (first non-flag argument after 'exec')
-        let foundExec = false;
-        for (let i = 0; i < parts.length; i++) {
-            const part = parts[i];
-            if (part === 'exec') {
-                foundExec = true;
-                continue;
-            }
-            if (foundExec) {
-                // Skip flags
-                if (part.startsWith('-')) {
-                    // Check if it's a flag with a value
-                    if (part === '-e' || part === '-w' || part === '-u') {
-                        i++; // Skip the next part (flag value)
-                    }
-                    continue;
-                }
-                // This should be the container ID
-                containerId = part;
-                break;
-            }
-        }
-        if (!containerId) {
-            throw new Error('Could not parse container ID from Docker command');
-        }
-        return {
-            containerId,
-        };
+  }
+  /**
+   * Get the shell type
+   */
+  async getShellType() {
+    return this.shellType;
+  }
+  /**
+   * Get the operating system type
+   */
+  async getOSType() {
+    return this.osType;
+  }
+  /**
+   * Get breadcrumb information for the UI
+   */
+  getBreadcrumbs() {
+    if (!this.config) {
+      return [];
     }
-    /**
-     * Verify that the container exists and is running
-     */
-    async verifyContainer() {
-        if (!this.config) {
-            throw new Error('No container configuration');
-        }
-        try {
-            // Use docker inspect to check container status
-            const command = `docker inspect --format="{{.State.Running}},{{.Name}}" ${this.config.containerId}`;
-            const { stdout } = await this.executeHostCommand(command);
-            const [running, name] = stdout.trim().split(',');
-            if (running !== 'true') {
-                throw new Error(`Container ${this.config.containerId} is not running`);
-            }
-            // Store container name (remove leading /)
-            if (name) {
-                this.config.containerName = name.replace(/^\//, '');
-            }
-        }
-        catch (error) {
-            if (error.message.includes('No such object')) {
-                throw new Error(`Container ${this.config.containerId} does not exist`);
-            }
-            throw error;
-        }
+    const displayName = this.config.containerName || this.config.containerId.substring(0, 12);
+    return [
+      {
+        label: "docker",
+        color: "blue"
+      },
+      {
+        label: displayName,
+        color: "blue"
+      }
+    ];
+  }
+  // Private helper methods
+  /**
+   * Parse Docker exec command to extract container ID
+   */
+  parseDockerCommand(command) {
+    const parts = command.trim().split(/\s+/);
+    let containerId = "";
+    let foundExec = false;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "exec") {
+        foundExec = true;
+        continue;
+      }
+      if (foundExec) {
+        if (part.startsWith("-")) {
+          if (part === "-e" || part === "-w" || part === "-u") {
+            i++;
+          }
+          continue;
+        }
+        containerId = part;
+        break;
+      }
     }
-    /**
-     * Detect the shell type in the Docker container
-     */
-    async detectShellType() {
-        if (!this.config) {
-            return 'sh';
-        }
-        try {
-            // Try to detect shell
-            const command = `docker exec ${this.config.containerId} sh -c "echo \\$SHELL"`;
-            const { stdout } = await this.executeHostCommand(command);
-            const shellPath = stdout.trim();
-            if (shellPath.includes('bash'))
-                return 'bash';
-            if (shellPath.includes('zsh'))
-                return 'zsh';
-            if (shellPath.includes('fish'))
-                return 'fish';
-            // Default to sh for containers
-            return 'sh';
-        }
-        catch {
-            return 'sh';
-        }
+    if (!containerId) {
+      throw new Error("Could not parse container ID from Docker command");
     }
-    /**
-     * Detect the operating system type in the Docker container
-     */
-    async detectOSType() {
-        if (!this.config) {
-            return 'linux';
-        }
-        try {
-            const command = `docker exec ${this.config.containerId} uname -s`;
-            const { stdout } = await this.executeHostCommand(command);
-            const osName = stdout.trim().toLowerCase();
-            if (osName.includes('darwin'))
-                return 'macos';
-            if (osName.includes('linux'))
-                return 'linux';
-            // Most containers are Linux
-            return 'linux';
-        }
-        catch {
-            return 'linux';
-        }
+    return {
+      containerId
+    };
+  }
+  /**
+   * Verify that the container exists and is running
+   */
+  async verifyContainer() {
+    if (!this.config) {
+      throw new Error("No container configuration");
     }
-    /**
-     * Build a Docker exec command with working directory context
-     */
-    buildDockerCommand(command, pwdTag = '__CENTAURUS_PWD__') {
-        if (!this.config) {
-            throw new Error('Not connected to Docker container');
-        }
-        // Add pwd tracking to command - escape $ so it's evaluated inside Docker, not by SSH shell
-        const commandWithPwd = `${command}; echo "${pwdTag}:\\$(pwd)"`;
-        // Use -w flag to set working directory
-        return `docker exec -w "${this.currentWorkingDirectory}" ${this.config.containerId} sh -c "${commandWithPwd.replace(/"/g, '\\"')}"`;
+    try {
+      const command = `docker inspect --format="{{.State.Running}},{{.Name}}" ${this.config.containerId}`;
+      const { stdout } = await this.executeHostCommand(command);
+      const [running, name] = stdout.trim().split(",");
+      if (running !== "true") {
+        throw new Error(`Container ${this.config.containerId} is not running`);
+      }
+      if (name) {
+        this.config.containerName = name.replace(/^\//, "");
+      }
+    } catch (error) {
+      if (error.message.includes("No such object")) {
+        throw new Error(`Container ${this.config.containerId} does not exist`);
+      }
+      throw error;
     }
-    /**
-     * Resolve a path to an absolute path
-     */
-    resolveAbsolutePath(path) {
-        if (path.startsWith('/')) {
-            return path;
-        }
-        if (path.startsWith('~')) {
-            return path;
-        }
-        return `${this.currentWorkingDirectory}/${path}`;
+  }
+  /**
+   * Detect the shell type in the Docker container
+   */
+  async detectShellType() {
+    if (!this.config) {
+      return "sh";
     }
-    /**
-     * 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;
+    try {
+      const command = `docker exec ${this.config.containerId} sh -c "echo \\$SHELL"`;
+      const { stdout } = await this.executeHostCommand(command);
+      const shellPath = stdout.trim();
+      if (shellPath.includes("bash")) return "bash";
+      if (shellPath.includes("zsh")) return "zsh";
+      if (shellPath.includes("fish")) return "fish";
+      return "sh";
+    } catch {
+      return "sh";
     }
-    /**
-     * 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;
+  }
+  /**
+   * Detect the operating system type in the Docker container
+   */
+  async detectOSType() {
+    if (!this.config) {
+      return "linux";
     }
-    /**
-     * 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)),
-        ]);
+    try {
+      const command = `docker exec ${this.config.containerId} uname -s`;
+      const { stdout } = await this.executeHostCommand(command);
+      const osName = stdout.trim().toLowerCase();
+      if (osName.includes("darwin")) return "macos";
+      if (osName.includes("linux")) return "linux";
+      return "linux";
+    } catch {
+      return "linux";
     }
-    /**
-     * Execute a command on the host (local or remote)
-     */
-    async executeHostCommand(command) {
-        if (this.parentContext) {
-            // Remote execution via parent context
-            try {
-                const result = await this.parentContext.handler.executeCommand(command);
-                return {
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                };
-            }
-            catch (error) {
-                throw {
-                    message: error.message,
-                    code: error.exitCode || 1,
-                    stderr: error.stderr || error.message
-                };
-            }
-        }
-        // Local execution via child_process
-        return execAsync(command);
+  }
+  /**
+   * Build a Docker exec command with working directory context
+   */
+  buildDockerCommand(command, pwdTag = "__CENTAURUS_PWD__") {
+    if (!this.config) {
+      throw new Error("Not connected to Docker container");
     }
-    /**
-     * Create a new instance of this handler
-     */
-    createNew() {
-        return new DockerHandler();
+    const commandWithPwd = `${command}; echo "${pwdTag}:\\$(pwd)"`;
+    return `docker exec -w "${this.currentWorkingDirectory}" ${this.config.containerId} sh -c "${commandWithPwd.replace(/"/g, '\\"')}"`;
+  }
+  /**
+   * Resolve a path to an absolute path
+   */
+  resolveAbsolutePath(path) {
+    if (path.startsWith("/")) {
+      return path;
+    }
+    if (path.startsWith("~")) {
+      return 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
+        )
+      )
+    ]);
+  }
+  /**
+   * Execute a command on the host (local or remote)
+   */
+  async executeHostCommand(command) {
+    if (this.parentContext) {
+      try {
+        const result = await this.parentContext.handler.executeCommand(command);
+        return {
+          stdout: result.stdout,
+          stderr: result.stderr
+        };
+      } catch (error) {
+        throw {
+          message: error.message,
+          code: error.exitCode || 1,
+          stderr: error.stderr || error.message
+        };
+      }
     }
+    return execAsync(command);
+  }
+  /**
+   * Create a new instance of this handler
+   */
+  createNew() {
+    return new DockerHandler();
+  }
 }
+export {
+  DockerHandler
+};
 //# sourceMappingURL=docker-handler.js.map