centaurus-cli 3.0.1 → 3.1.0

package/dist/context/context-manager.js

@@ -1,529 +1,544 @@
-/**
- * Context Manager - Central orchestrator for subshell state management
- */
-import { randomUUID } from 'crypto';
-import { SubshellConnectionError, SubshellExecutionError, } from './types.js';
-import { logError, logWarning } from '../utils/logger.js';
-/**
- * Context Manager manages the execution context stack and routes commands
- * to the appropriate handler (local or subshell)
- */
-export class ContextManager {
-    initialCwd;
-    platform;
-    contextStack = [];
-    handlers = new Map();
-    contextChangeCallbacks = [];
-    userNotificationCallbacks = [];
-    constructor(initialCwd, platform) {
-        this.initialCwd = initialCwd;
-        this.platform = platform;
-        // Initialize with local context
-        this.contextStack.push(this.createLocalContext(initialCwd));
-    }
-    /**
-     * Create a local context
-     */
-    createLocalContext(cwd) {
-        return {
-            type: 'local',
-            metadata: {
-                workingDirectory: cwd,
-                shell: this.detectLocalShell(),
-                os: this.detectLocalOS(),
-            },
-            connectionState: 'connected',
-            sessionId: randomUUID(),
-        };
-    }
-    /**
-     * Detect the local shell type
-     */
-    detectLocalShell() {
-        const shell = process.env.SHELL || process.env.ComSpec || 'unknown';
-        if (shell.includes('bash'))
-            return 'bash';
-        if (shell.includes('zsh'))
-            return 'zsh';
-        if (shell.includes('fish'))
-            return 'fish';
-        if (shell.includes('cmd'))
-            return 'cmd';
-        if (shell.includes('powershell') || shell.includes('pwsh'))
-            return 'powershell';
-        return 'unknown';
-    }
-    /**
-     * Detect the local operating system
-     */
-    detectLocalOS() {
-        switch (this.platform) {
-            case 'win32':
-                return 'windows';
-            case 'darwin':
-                return 'macos';
-            default:
-                return 'linux';
-        }
-    }
-    /**
-     * Get the current execution context
-     */
-    getCurrentContext() {
-        return this.contextStack[this.contextStack.length - 1];
-    }
-    /**
-     * Get the parent context (one level up in the stack)
-     * Returns null if at local context or only one context exists.
-     * Useful for detecting nested sessions (e.g., Docker inside SSH).
-     */
-    getParentContext() {
-        if (this.contextStack.length <= 1) {
-            return null;
-        }
-        return this.contextStack[this.contextStack.length - 2];
-    }
-    /**
-     * Push a new context onto the stack
-     */
-    pushContext(context) {
-        this.contextStack.push(context);
-        this.notifyContextChange();
-    }
-    /**
-     * Get the full context stack
-     */
-    getContextStack() {
-        return [...this.contextStack];
-    }
-    /**
-     * Pop the current context from the stack
-     * @returns The popped context, or null if only local context remains
-     */
-    popContext() {
-        if (this.contextStack.length <= 1) {
-            // Don't pop the local context
-            return null;
-        }
-        const popped = this.contextStack.pop();
-        this.notifyContextChange();
-        return popped;
-    }
-    /**
-     * Register a subshell handler
-     */
-    registerHandler(type, handler) {
-        this.handlers.set(type, handler);
-    }
-    /**
-     * Get a registered handler by type
-     */
-    getHandler(type) {
-        return this.handlers.get(type);
-    }
-    /**
-     * Get all registered handlers
-     */
-    getAllHandlers() {
-        return Array.from(this.handlers.values());
-    }
-    /**
-     * Update the working directory of the current context
-     */
-    updateWorkingDirectory(path) {
-        const current = this.getCurrentContext();
-        current.metadata.workingDirectory = path;
-        this.notifyContextChange();
-    }
-    /**
-     * Update the connection state of the current context
-     */
-    updateConnectionState(state) {
-        const current = this.getCurrentContext();
-        current.connectionState = state;
-        this.notifyContextChange();
-    }
-    /**
-     * Register a callback for context changes
-     */
-    onContextChange(callback) {
-        this.contextChangeCallbacks.push(callback);
-    }
-    /**
-     * Register a callback for user notifications
-     */
-    onUserNotification(callback) {
-        this.userNotificationCallbacks.push(callback);
-    }
-    /**
-     * Notify all registered callbacks of a context change
-     */
-    notifyContextChange() {
-        const current = this.getCurrentContext();
-        // Pass a copy of the stack to prevent mutation by listeners
-        const stack = [...this.contextStack];
-        this.contextChangeCallbacks.forEach(callback => {
-            try {
-                callback(current, stack);
-            }
-            catch (error) {
-                logError('Error in context change callback', error);
-            }
-        });
-    }
-    /**
-     * Notify user with a message
-     */
-    notifyUser(message, type = 'info') {
-        this.userNotificationCallbacks.forEach(callback => {
-            try {
-                callback(message, type);
-            }
-            catch (error) {
-                logError('Error in user notification callback', error);
-            }
-        });
-        // Fallback to console if no callbacks registered
-        if (this.userNotificationCallbacks.length === 0) {
-            logWarning(`${type.toUpperCase()}: ${message}`);
-        }
-    }
-    /**
-     * Execute a command in the current context with timeout
-     * @param command The command to execute
-     * @param timeoutMs Timeout in milliseconds (default 30000)
-     * @param cwd Optional working directory - if provided, command will be prefixed with 'cd <cwd> &&' for remote contexts
-     */
-    async executeCommand(command, timeoutMs = 30000, cwd) {
-        const context = this.getCurrentContext();
-        const startTime = Date.now();
-        try {
-            let result;
-            if (context.type === 'local') {
-                // Execute locally using Node.js child_process
-                // Use provided cwd or fall back to context's working directory
-                const workingDir = cwd || context.metadata.workingDirectory;
-                result = await this.executeWithTimeout(() => this.executeLocalCommand(command, workingDir), timeoutMs, 'Command execution');
-                // Update context cwd if execution was successful and cwd was provided
-                if (cwd && result.exitCode === 0 && cwd !== context.metadata.workingDirectory) {
-                    context.metadata.workingDirectory = cwd;
-                    this.notifyContextChange();
-                }
-            }
-            else {
-                // Execute in subshell
-                if (!context.handler) {
-                    throw new SubshellExecutionError(command, 'No handler available for current context', 1);
-                }
-                // For remote contexts, prefix command with 'cd <cwd> &&' if cwd is provided and valid
-                let fullCommand = command;
-                if (cwd && cwd !== '~' && cwd !== context.metadata.workingDirectory) {
-                    // Prefix with cd to ensure command runs in the correct directory
-                    fullCommand = `cd "${cwd}" && ${command}`;
-                }
-                result = await this.executeWithTimeout(() => context.handler.executeCommand(fullCommand), timeoutMs, 'Command execution');
-                // Update working directory after command execution
-                try {
-                    const newCwd = await context.handler.getCurrentWorkingDirectory();
-                    // Only update if we got a valid path (not ~ which is the fallback)
-                    if (newCwd && newCwd !== '~' && newCwd !== context.metadata.workingDirectory) {
-                        context.metadata.workingDirectory = newCwd;
-                        this.notifyContextChange();
-                    }
-                }
-                catch (cwdError) {
-                    // Ignore cwd detection errors - don't change the stored CWD
-                    // The previous CWD should remain valid
-                }
-            }
-            // Check for latency warning
-            const executionTime = Date.now() - startTime;
-            if (executionTime > 2000) {
-                this.notifyUser(`Command took ${(executionTime / 1000).toFixed(1)}s to execute (high latency detected)`, 'warning');
-            }
-            return result;
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('timed out')) {
-                this.notifyUser(`Command timed out after ${timeoutMs / 1000}s`, 'error');
-                throw new SubshellExecutionError(command, `Command timed out after ${timeoutMs / 1000}s`, 124 // Standard timeout exit code
-                );
-            }
-            throw new SubshellExecutionError(command, error instanceof Error ? error.message : String(error), 1);
-        }
-    }
-    /**
-     * Execute a command locally
-     */
-    async executeLocalCommand(command, cwd) {
-        const { exec } = await import('child_process');
-        const { promisify } = await import('util');
-        const execAsync = promisify(exec);
-        try {
-            const { stdout, stderr } = await execAsync(command, { cwd });
-            return {
-                stdout: stdout || '',
-                stderr: stderr || '',
-                exitCode: 0,
-            };
+import { randomUUID } from "crypto";
+import {
+  SubshellConnectionError,
+  SubshellExecutionError
+} from "./types.js";
+import { logError, logWarning } from "../utils/logger.js";
+class ContextManager {
+  constructor(initialCwd, platform) {
+    this.initialCwd = initialCwd;
+    this.platform = platform;
+    this.contextStack.push(this.createLocalContext(initialCwd));
+  }
+  contextStack = [];
+  handlers = /* @__PURE__ */ new Map();
+  contextChangeCallbacks = [];
+  userNotificationCallbacks = [];
+  /**
+   * Create a local context
+   */
+  createLocalContext(cwd) {
+    return {
+      type: "local",
+      metadata: {
+        workingDirectory: cwd,
+        shell: this.detectLocalShell(),
+        os: this.detectLocalOS()
+      },
+      connectionState: "connected",
+      sessionId: randomUUID()
+    };
+  }
+  /**
+   * Detect the local shell type
+   */
+  detectLocalShell() {
+    const shell = process.env.SHELL || process.env.ComSpec || "unknown";
+    if (shell.includes("bash")) return "bash";
+    if (shell.includes("zsh")) return "zsh";
+    if (shell.includes("fish")) return "fish";
+    if (shell.includes("cmd")) return "cmd";
+    if (shell.includes("powershell") || shell.includes("pwsh")) return "powershell";
+    return "unknown";
+  }
+  /**
+   * Detect the local operating system
+   */
+  detectLocalOS() {
+    switch (this.platform) {
+      case "win32":
+        return "windows";
+      case "darwin":
+        return "macos";
+      default:
+        return "linux";
+    }
+  }
+  /**
+   * Get the current execution context
+   */
+  getCurrentContext() {
+    return this.contextStack[this.contextStack.length - 1];
+  }
+  /**
+   * Get the parent context (one level up in the stack)
+   * Returns null if at local context or only one context exists.
+   * Useful for detecting nested sessions (e.g., Docker inside SSH).
+   */
+  getParentContext() {
+    if (this.contextStack.length <= 1) {
+      return null;
+    }
+    return this.contextStack[this.contextStack.length - 2];
+  }
+  /**
+   * Push a new context onto the stack
+   */
+  pushContext(context) {
+    this.contextStack.push(context);
+    this.notifyContextChange();
+  }
+  /**
+   * Get the full context stack
+   */
+  getContextStack() {
+    return [...this.contextStack];
+  }
+  /**
+   * Pop the current context from the stack
+   * @returns The popped context, or null if only local context remains
+   */
+  popContext() {
+    if (this.contextStack.length <= 1) {
+      return null;
+    }
+    const popped = this.contextStack.pop();
+    this.notifyContextChange();
+    return popped;
+  }
+  /**
+   * Register a subshell handler
+   */
+  registerHandler(type, handler) {
+    this.handlers.set(type, handler);
+  }
+  /**
+   * Get a registered handler by type
+   */
+  getHandler(type) {
+    return this.handlers.get(type);
+  }
+  /**
+   * Get all registered handlers
+   */
+  getAllHandlers() {
+    return Array.from(this.handlers.values());
+  }
+  /**
+   * Update the working directory of the current context
+   */
+  updateWorkingDirectory(path) {
+    const current = this.getCurrentContext();
+    current.metadata.workingDirectory = path;
+    this.notifyContextChange();
+  }
+  /**
+   * Update the connection state of the current context
+   */
+  updateConnectionState(state) {
+    const current = this.getCurrentContext();
+    current.connectionState = state;
+    this.notifyContextChange();
+  }
+  /**
+   * Register a callback for context changes
+   */
+  onContextChange(callback) {
+    this.contextChangeCallbacks.push(callback);
+  }
+  /**
+   * Register a callback for user notifications
+   */
+  onUserNotification(callback) {
+    this.userNotificationCallbacks.push(callback);
+  }
+  /**
+   * Notify all registered callbacks of a context change
+   */
+  notifyContextChange() {
+    const current = this.getCurrentContext();
+    const stack = [...this.contextStack];
+    this.contextChangeCallbacks.forEach((callback) => {
+      try {
+        callback(current, stack);
+      } catch (error) {
+        logError("Error in context change callback", error);
+      }
+    });
+  }
+  /**
+   * Notify user with a message
+   */
+  notifyUser(message, type = "info") {
+    this.userNotificationCallbacks.forEach((callback) => {
+      try {
+        callback(message, type);
+      } catch (error) {
+        logError("Error in user notification callback", error);
+      }
+    });
+    if (this.userNotificationCallbacks.length === 0) {
+      logWarning(`${type.toUpperCase()}: ${message}`);
+    }
+  }
+  /**
+   * Execute a command in the current context with timeout
+   * @param command The command to execute
+   * @param timeoutMs Timeout in milliseconds (default 30000)
+   * @param cwd Optional working directory - if provided, command will be prefixed with 'cd <cwd> &&' for remote contexts
+   */
+  async executeCommand(command, timeoutMs = 3e4, cwd) {
+    const context = this.getCurrentContext();
+    const startTime = Date.now();
+    try {
+      let result;
+      if (context.type === "local") {
+        const workingDir = cwd || context.metadata.workingDirectory;
+        result = await this.executeWithTimeout(
+          () => this.executeLocalCommand(command, workingDir),
+          timeoutMs,
+          "Command execution"
+        );
+        if (cwd && result.exitCode === 0 && cwd !== context.metadata.workingDirectory) {
+          context.metadata.workingDirectory = cwd;
+          this.notifyContextChange();
         }
-        catch (error) {
-            return {
-                stdout: error.stdout || '',
-                stderr: error.stderr || error.message || '',
-                exitCode: error.code || 1,
-            };
+      } else {
+        if (!context.handler) {
+          throw new SubshellExecutionError(
+            command,
+            "No handler available for current context",
+            1
+          );
         }
-    }
-    /**
-     * Read a file in the current context with timeout
-     */
-    async readFile(path, timeoutMs = 10000) {
-        const context = this.getCurrentContext();
-        try {
-            if (context.type === 'local') {
-                const fs = await import('fs/promises');
-                return await this.executeWithTimeout(() => fs.readFile(path, 'utf-8'), timeoutMs, 'File read');
-            }
-            if (!context.handler) {
-                throw new Error('No handler available for current context');
-            }
-            return await this.executeWithTimeout(() => context.handler.readFile(path), timeoutMs, 'File read');
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('timed out')) {
-                this.notifyUser(`File read timed out after ${timeoutMs / 1000}s`, 'error');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Write a file in the current context with timeout
-     */
-    async writeFile(path, content, timeoutMs = 10000) {
-        const context = this.getCurrentContext();
-        try {
-            if (context.type === 'local') {
-                const fs = await import('fs/promises');
-                await this.executeWithTimeout(() => fs.writeFile(path, content, 'utf-8'), timeoutMs, 'File write');
-                return;
-            }
-            if (!context.handler) {
-                throw new Error('No handler available for current context');
-            }
-            await this.executeWithTimeout(() => context.handler.writeFile(path, content), timeoutMs, 'File write');
+        let fullCommand = command;
+        if (cwd && cwd !== "~" && cwd !== context.metadata.workingDirectory) {
+          fullCommand = `cd "${cwd}" && ${command}`;
         }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('timed out')) {
-                this.notifyUser(`File write timed out after ${timeoutMs / 1000}s`, 'error');
-            }
-            throw error;
-        }
-    }
-    /**
-     * List directory contents in the current context with timeout
-     */
-    async listDirectory(path, timeoutMs = 10000) {
-        const context = this.getCurrentContext();
+        result = await this.executeWithTimeout(
+          () => context.handler.executeCommand(fullCommand),
+          timeoutMs,
+          "Command execution"
+        );
         try {
-            if (context.type === 'local') {
-                const fs = await import('fs/promises');
-                return await this.executeWithTimeout(async () => {
-                    const entries = await fs.readdir(path, { withFileTypes: true });
-                    return entries.map(entry => ({
-                        name: entry.name,
-                        type: entry.isDirectory() ? 'directory' : 'file',
-                    }));
-                }, timeoutMs, 'Directory listing');
-            }
-            if (!context.handler) {
-                throw new Error('No handler available for current context');
-            }
-            return await this.executeWithTimeout(() => context.handler.listDirectory(path), timeoutMs, 'Directory listing');
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('timed out')) {
-                this.notifyUser(`Directory listing timed out after ${timeoutMs / 1000}s`, 'error');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Search for files in the current context with timeout
-     */
-    async searchFiles(pattern, directory, timeoutMs = 30000) {
-        const context = this.getCurrentContext();
-        try {
-            if (context.type === 'local') {
-                // For local, we'll use grep via command execution
-                const result = await this.executeWithTimeout(() => this.executeLocalCommand(`grep -rn "${pattern}" "${directory}" 2>/dev/null || true`, context.metadata.workingDirectory), timeoutMs, 'File search');
-                return this.parseGrepOutput(result.stdout);
-            }
-            if (!context.handler) {
-                throw new Error('No handler available for current context');
-            }
-            return await this.executeWithTimeout(() => context.handler.searchFiles(pattern, directory), timeoutMs, 'File search');
-        }
-        catch (error) {
-            if (error instanceof Error && error.message.includes('timed out')) {
-                this.notifyUser(`File search timed out after ${timeoutMs / 1000}s`, 'error');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Parse grep output into SearchResult array
-     */
-    parseGrepOutput(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],
-                });
-            }
+          const newCwd = await context.handler.getCurrentWorkingDirectory();
+          if (newCwd && newCwd !== "~" && newCwd !== context.metadata.workingDirectory) {
+            context.metadata.workingDirectory = newCwd;
+            this.notifyContextChange();
+          }
+        } catch (cwdError) {
         }
-        return results;
-    }
-    /**
-     * Connect to a subshell with error handling
-     */
-    async connectToSubshell(handler, command) {
+      }
+      const executionTime = Date.now() - startTime;
+      if (executionTime > 2e3) {
+        this.notifyUser(
+          `Command took ${(executionTime / 1e3).toFixed(1)}s to execute (high latency detected)`,
+          "warning"
+        );
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        this.notifyUser(`Command timed out after ${timeoutMs / 1e3}s`, "error");
+        throw new SubshellExecutionError(
+          command,
+          `Command timed out after ${timeoutMs / 1e3}s`,
+          124
+          // Standard timeout exit code
+        );
+      }
+      throw new SubshellExecutionError(
+        command,
+        error instanceof Error ? error.message : String(error),
+        1
+      );
+    }
+  }
+  /**
+   * Execute a command locally
+   */
+  async executeLocalCommand(command, cwd) {
+    const { exec } = await import("child_process");
+    const { promisify } = await import("util");
+    const execAsync = promisify(exec);
+    try {
+      const { stdout, stderr } = await execAsync(command, { cwd });
+      return {
+        stdout: stdout || "",
+        stderr: stderr || "",
+        exitCode: 0
+      };
+    } catch (error) {
+      return {
+        stdout: error.stdout || "",
+        stderr: error.stderr || error.message || "",
+        exitCode: error.code || 1
+      };
+    }
+  }
+  /**
+   * Read a file in the current context with timeout
+   */
+  async readFile(path, timeoutMs = 1e4) {
+    const context = this.getCurrentContext();
+    try {
+      if (context.type === "local") {
+        const fs = await import("fs/promises");
+        return await this.executeWithTimeout(
+          () => fs.readFile(path, "utf-8"),
+          timeoutMs,
+          "File read"
+        );
+      }
+      if (!context.handler) {
+        throw new Error("No handler available for current context");
+      }
+      return await this.executeWithTimeout(
+        () => context.handler.readFile(path),
+        timeoutMs,
+        "File read"
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        this.notifyUser(`File read timed out after ${timeoutMs / 1e3}s`, "error");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Write a file in the current context with timeout
+   */
+  async writeFile(path, content, timeoutMs = 1e4) {
+    const context = this.getCurrentContext();
+    try {
+      if (context.type === "local") {
+        const fs = await import("fs/promises");
+        await this.executeWithTimeout(
+          () => fs.writeFile(path, content, "utf-8"),
+          timeoutMs,
+          "File write"
+        );
+        return;
+      }
+      if (!context.handler) {
+        throw new Error("No handler available for current context");
+      }
+      await this.executeWithTimeout(
+        () => context.handler.writeFile(path, content),
+        timeoutMs,
+        "File write"
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        this.notifyUser(`File write timed out after ${timeoutMs / 1e3}s`, "error");
+      }
+      throw error;
+    }
+  }
+  /**
+   * List directory contents in the current context with timeout
+   */
+  async listDirectory(path, timeoutMs = 1e4) {
+    const context = this.getCurrentContext();
+    try {
+      if (context.type === "local") {
+        const fs = await import("fs/promises");
+        return await this.executeWithTimeout(
+          async () => {
+            const entries = await fs.readdir(path, { withFileTypes: true });
+            return entries.map((entry) => ({
+              name: entry.name,
+              type: entry.isDirectory() ? "directory" : "file"
+            }));
+          },
+          timeoutMs,
+          "Directory listing"
+        );
+      }
+      if (!context.handler) {
+        throw new Error("No handler available for current context");
+      }
+      return await this.executeWithTimeout(
+        () => context.handler.listDirectory(path),
+        timeoutMs,
+        "Directory listing"
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        this.notifyUser(`Directory listing timed out after ${timeoutMs / 1e3}s`, "error");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Search for files in the current context with timeout
+   */
+  async searchFiles(pattern, directory, timeoutMs = 3e4) {
+    const context = this.getCurrentContext();
+    try {
+      if (context.type === "local") {
+        const result = await this.executeWithTimeout(
+          () => this.executeLocalCommand(
+            `grep -rn "${pattern}" "${directory}" 2>/dev/null || true`,
+            context.metadata.workingDirectory
+          ),
+          timeoutMs,
+          "File search"
+        );
+        return this.parseGrepOutput(result.stdout);
+      }
+      if (!context.handler) {
+        throw new Error("No handler available for current context");
+      }
+      return await this.executeWithTimeout(
+        () => context.handler.searchFiles(pattern, directory),
+        timeoutMs,
+        "File search"
+      );
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        this.notifyUser(`File search timed out after ${timeoutMs / 1e3}s`, "error");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Parse grep output into SearchResult array
+   */
+  parseGrepOutput(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;
+  }
+  /**
+   * Connect to a subshell with error handling
+   */
+  async connectToSubshell(handler, command) {
+    try {
+      this.updateConnectionState("connecting");
+      this.notifyUser(`Connecting to ${handler.type}...`, "info");
+      const cwd = this.getCurrentContext().metadata.workingDirectory;
+      const context = await handler.connect(command, cwd);
+      this.pushContext(context);
+      this.updateConnectionState("connected");
+      this.notifyUser(`Connected to ${handler.type} successfully`, "info");
+    } catch (error) {
+      this.updateConnectionState("error");
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.notifyUser(`Failed to connect: ${errorMessage}`, "error");
+      if (error instanceof SubshellConnectionError && error.recoverable) {
+        this.notifyUser("Attempting to reconnect...", "info");
         try {
-            this.updateConnectionState('connecting');
-            this.notifyUser(`Connecting to ${handler.type}...`, 'info');
-            const cwd = this.getCurrentContext().metadata.workingDirectory;
-            const context = await handler.connect(command, cwd);
-            this.pushContext(context);
-            this.updateConnectionState('connected');
-            this.notifyUser(`Connected to ${handler.type} successfully`, 'info');
-        }
-        catch (error) {
-            this.updateConnectionState('error');
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.notifyUser(`Failed to connect: ${errorMessage}`, 'error');
-            // Check if error is recoverable
-            if (error instanceof SubshellConnectionError && error.recoverable) {
-                this.notifyUser('Attempting to reconnect...', 'info');
-                try {
-                    await this.attemptReconnection(handler, command);
-                }
-                catch (reconnectError) {
-                    const reconnectMsg = reconnectError instanceof Error ? reconnectError.message : String(reconnectError);
-                    this.notifyUser(`Reconnection failed: ${reconnectMsg}`, 'error');
-                    this.restoreLocalContext();
-                }
-            }
-            else {
-                // Non-recoverable error, restore local context
-                this.restoreLocalContext();
-            }
-            throw error;
-        }
-    }
-    /**
-     * Restore local context after connection failure
-     */
-    restoreLocalContext() {
-        // Pop all subshell contexts and return to local
-        while (this.contextStack.length > 1) {
-            const context = this.contextStack.pop();
-            if (context?.handler) {
-                context.handler.disconnect().catch((err) => {
-                    logError('Error disconnecting handler', err);
-                });
-            }
-        }
-        this.updateConnectionState('connected');
-        this.notifyUser('Restored local context', 'info');
-    }
-    /**
-     * Attempt to reconnect to a subshell
-     */
-    async attemptReconnection(handler, command, maxAttempts = 3) {
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
-            this.notifyUser(`Reconnection attempt ${attempt}/${maxAttempts}...`, 'info');
-            await this.sleep(delay);
-            try {
-                const cwd = this.getCurrentContext().metadata.workingDirectory;
-                const context = await handler.connect(command, cwd);
-                this.pushContext(context);
-                this.updateConnectionState('connected');
-                this.notifyUser('Reconnected successfully', 'info');
-                return;
-            }
-            catch (error) {
-                if (attempt === maxAttempts) {
-                    throw new SubshellConnectionError(handler.type, 'Reconnection failed after maximum attempts', false);
-                }
-            }
+          await this.attemptReconnection(handler, command);
+        } catch (reconnectError) {
+          const reconnectMsg = reconnectError instanceof Error ? reconnectError.message : String(reconnectError);
+          this.notifyUser(`Reconnection failed: ${reconnectMsg}`, "error");
+          this.restoreLocalContext();
         }
-    }
-    /**
-     * Utility method to sleep for a specified duration
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Execute an operation 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)),
-        ]);
-    }
-    /**
-     * Reset to local context (for error recovery)
-     */
-    resetToLocal() {
-        // Disconnect all subshells
-        const handlers = this.contextStack
-            .filter(ctx => ctx.handler)
-            .map(ctx => ctx.handler);
-        // Clear stack except local context
-        this.contextStack = [this.contextStack[0]];
-        // Disconnect handlers asynchronously
-        handlers.forEach(handler => {
-            handler.disconnect().catch((err) => {
-                logError('Error disconnecting handler', err);
-            });
+      } else {
+        this.restoreLocalContext();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Restore local context after connection failure
+   */
+  restoreLocalContext() {
+    while (this.contextStack.length > 1) {
+      const context = this.contextStack.pop();
+      if (context?.handler) {
+        context.handler.disconnect().catch((err) => {
+          logError("Error disconnecting handler", err);
         });
-        this.notifyContextChange();
-    }
-    /**
-     * Handle connection loss and attempt recovery
-     */
-    async handleConnectionLoss(error) {
-        const context = this.getCurrentContext();
-        if (context.type === 'local') {
-            // Already in local context, nothing to do
-            return;
+      }
+    }
+    this.updateConnectionState("connected");
+    this.notifyUser("Restored local context", "info");
+  }
+  /**
+   * Attempt to reconnect to a subshell
+   */
+  async attemptReconnection(handler, command, maxAttempts = 3) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 8e3);
+      this.notifyUser(`Reconnection attempt ${attempt}/${maxAttempts}...`, "info");
+      await this.sleep(delay);
+      try {
+        const cwd = this.getCurrentContext().metadata.workingDirectory;
+        const context = await handler.connect(command, cwd);
+        this.pushContext(context);
+        this.updateConnectionState("connected");
+        this.notifyUser("Reconnected successfully", "info");
+        return;
+      } catch (error) {
+        if (attempt === maxAttempts) {
+          throw new SubshellConnectionError(
+            handler.type,
+            "Reconnection failed after maximum attempts",
+            false
+          );
         }
-        this.updateConnectionState('error');
-        this.notifyUser(`Connection lost: ${error.message}`, 'error');
-        // Try to reconnect if handler is available
-        if (context.handler) {
-            try {
-                this.notifyUser('Attempting to reconnect...', 'info');
-                // We need the original command to reconnect, but we don't have it stored
-                // For now, we'll just restore local context
-                this.restoreLocalContext();
-            }
-            catch (reconnectError) {
-                this.notifyUser('Reconnection failed, restoring local context', 'error');
-                this.restoreLocalContext();
-            }
-        }
-        else {
-            this.restoreLocalContext();
-        }
-    }
+      }
+    }
+  }
+  /**
+   * Utility method to sleep for a specified duration
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Execute an operation 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
+        )
+      )
+    ]);
+  }
+  /**
+   * Reset to local context (for error recovery)
+   */
+  resetToLocal() {
+    const handlers = this.contextStack.filter((ctx) => ctx.handler).map((ctx) => ctx.handler);
+    this.contextStack = [this.contextStack[0]];
+    handlers.forEach((handler) => {
+      handler.disconnect().catch((err) => {
+        logError("Error disconnecting handler", err);
+      });
+    });
+    this.notifyContextChange();
+  }
+  /**
+   * Handle connection loss and attempt recovery
+   */
+  async handleConnectionLoss(error) {
+    const context = this.getCurrentContext();
+    if (context.type === "local") {
+      return;
+    }
+    this.updateConnectionState("error");
+    this.notifyUser(`Connection lost: ${error.message}`, "error");
+    if (context.handler) {
+      try {
+        this.notifyUser("Attempting to reconnect...", "info");
+        this.restoreLocalContext();
+      } catch (reconnectError) {
+        this.notifyUser("Reconnection failed, restoring local context", "error");
+        this.restoreLocalContext();
+      }
+    } else {
+      this.restoreLocalContext();
+    }
+  }
 }
+export {
+  ContextManager
+};
 //# sourceMappingURL=context-manager.js.map