@ebowwa/terminal 0.2.0

package/src/tmux-local.ts

@@ -0,0 +1,839 @@
+/**
+ * tmux-based Local Terminal Sessions
+ * Provides persistent terminal sessions using local tmux for SSH connections
+ * SSH connections stay active within tmux sessions on the local machine
+ */
+
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+/**
+ * Local tmux session configuration
+ */
+interface LocalTmuxConfig {
+  /** Session name prefix for local MCP SSH sessions */
+  sessionPrefix: string;
+  /** Default shell to use in tmux */
+  defaultShell: string;
+  /** Terminal type */
+  term: string;
+  /** Timeout for local commands (seconds) */
+  timeout: number;
+  /** Scrollback limit (lines) */
+  historyLimit: number;
+  /** Session age limit for cleanup (milliseconds) */
+  sessionAgeLimit: number;
+}
+
+const DEFAULT_CONFIG: LocalTmuxConfig = {
+  sessionPrefix: "mcp-ssh",
+  defaultShell: "/bin/bash",
+  term: "xterm-256color",
+  timeout: 30,
+  historyLimit: 10000, // 10k lines ~ 1-2MB per session
+  sessionAgeLimit: 30 * 24 * 60 * 60 * 1000, // 30 days
+};
+
+/**
+ * Options for creating a local tmux SSH session
+ */
+export interface LocalTmuxSessionOptions {
+  /** Initial command to run after SSH connection */
+  initialCommand?: string;
+  /** Custom session name (auto-generated if not provided) */
+  sessionName?: string;
+  /** Window name */
+  windowName?: string;
+}
+
+/**
+ * Result of creating a local tmux session
+ */
+export interface LocalTmuxSessionResult {
+  /** Session name */
+  sessionName: string;
+  /** Whether the session was newly created */
+  newlyCreated: boolean;
+  /** Full tmux command used to create the session */
+  command: string;
+}
+
+/**
+ * Check if tmux is installed locally
+ */
+export async function isLocalTmuxInstalled(): Promise<boolean> {
+  try {
+    const { stdout } = await execAsync("type tmux", { timeout: 5000 });
+    return stdout.trim() !== "tmux not found" && stdout.trim() !== "";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Generate a local tmux session name for a host
+ * @param host - Remote host IP or hostname
+ * @param user - SSH user (default: "root")
+ * @returns Session name (e.g., "mcp-ssh-192-168-1-1")
+ */
+export function generateLocalSessionName(host: string, user: string = "root"): string {
+  const sanitizedHost = host.replace(/[.]/g, "-");
+  return `${DEFAULT_CONFIG.sessionPrefix}-${sanitizedHost}`;
+}
+
+/**
+ * List all local tmux sessions
+ * @returns Array of session names
+ */
+export async function listLocalSessions(): Promise<string[]> {
+  try {
+    const { stdout } = await execAsync(
+      'tmux list-sessions -F "#{session_name}" 2>/dev/null || echo ""',
+      { timeout: 5000 }
+    );
+
+    if (!stdout || stdout.trim() === "") {
+      return [];
+    }
+
+    return stdout.trim().split("\n");
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Check if a specific local tmux session exists
+ * @param sessionName - Session name to check
+ * @returns True if session exists
+ */
+export async function hasLocalSession(sessionName: string): Promise<boolean> {
+  const sessions = await listLocalSessions();
+  return sessions.includes(sessionName);
+}
+
+/**
+ * Create a local tmux session with an active SSH connection
+ *
+ * This function creates a tmux session on the local machine that maintains
+ * an active SSH connection to the remote host. The connection stays alive
+ * within the tmux session, allowing for persistent interactions.
+ *
+ * @param host - Remote host IP or hostname
+ * @param user - SSH user (default: "root")
+ * @param keyPath - Path to SSH private key (for key-based auth)
+ * @param password - SSH password (for password-based auth)
+ * @param options - Additional options for session creation
+ * @returns Session creation result
+ *
+ * @example
+ * ```ts
+ * // Key-based authentication
+ * const result = await createLocalTmuxSSHSession(
+ *   "192.168.1.100",
+ *   "root",
+ *   "/path/to/key"
+ * );
+ *
+ * // Password-based authentication (requires sshpass)
+ * const result = await createLocalTmuxSSHSession(
+ *   "192.168.1.100",
+ *   "root",
+ *   undefined,
+ *   "mypassword"
+ * );
+ * ```
+ */
+export async function createLocalTmuxSSHSession(
+  host: string,
+  user: string = "root",
+  keyPath?: string,
+  password?: string,
+  options: LocalTmuxSessionOptions = {}
+): Promise<LocalTmuxSessionResult> {
+  // Check if tmux is installed
+  const tmuxInstalled = await isLocalTmuxInstalled();
+  if (!tmuxInstalled) {
+    throw new Error(
+      "tmux is not installed on the local machine. Please install it using: brew install tmux (macOS) or apt install tmux (Linux)"
+    );
+  }
+
+  const sessionName = options.sessionName || generateLocalSessionName(host, user);
+  const windowName = options.windowName || "ssh";
+
+  // Check if session already exists
+  const sessionExists = await hasLocalSession(sessionName);
+
+  if (sessionExists) {
+    // Session already exists, return info
+    return {
+      sessionName,
+      newlyCreated: false,
+      command: `tmux attach-session -t ${sessionName}`,
+    };
+  }
+
+  // Build SSH command based on auth method
+  let sshCommand: string;
+
+  if (keyPath) {
+    // Key-based authentication
+    sshCommand = `ssh -i ${keyPath} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null ${user}@${host}`;
+  } else if (password) {
+    // Password-based authentication using sshpass
+    // Check if sshpass is available
+    try {
+      await execAsync("type sshpass", { timeout: 5000 });
+      sshCommand = `sshpass -p '${password}' ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null ${user}@${host}`;
+    } catch {
+      throw new Error(
+        "Password authentication requires 'sshpass' to be installed. Please install it using: brew install sshpass (macOS) or apt install sshpass (Linux). Alternatively, use key-based authentication."
+      );
+    }
+  } else {
+    // No auth method provided, try default SSH agent
+    sshCommand = `ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null ${user}@${host}`;
+  }
+
+  // Create new tmux session with SSH connection
+  // We use new-session -d to create in detached mode
+  const createCmd = [
+    "tmux",
+    "new-session",
+    "-d",
+    "-s", sessionName,
+    "-n", windowName,
+    sshCommand,
+  ].join(" ");
+
+  try {
+    // Create the session
+    await execAsync(createCmd, { timeout: DEFAULT_CONFIG.timeout * 1000 });
+
+    // Configure the session
+    try {
+      await execAsync(
+        `tmux set-option -t "${sessionName}" history-limit ${DEFAULT_CONFIG.historyLimit}`,
+        { timeout: 5000 }
+      );
+    } catch {
+      // Ignore config errors
+    }
+
+    // If initial command is provided, send it after SSH connects
+    if (options.initialCommand) {
+      // Wait a moment for SSH to connect
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      await sendCommandToLocalSession(sessionName, options.initialCommand);
+    }
+
+    return {
+      sessionName,
+      newlyCreated: true,
+      command: createCmd,
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to create local tmux session: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+/**
+ * Send a command to a local tmux pane (already SSH'd into the remote host)
+ *
+ * This function sends a command to the tmux pane, which will be executed
+ * on the remote host since the SSH connection is already active.
+ *
+ * @param sessionName - Local tmux session name
+ * @param command - Command to send to the remote host
+ * @param paneIndex - Pane index (default: "0")
+ * @param windowName - Window name (default: auto-detects first window)
+ * @returns True if command was sent successfully
+ */
+export async function sendCommandToLocalSession(
+  sessionName: string,
+  command: string,
+  paneIndex: string = "0",
+  windowName?: string
+): Promise<boolean> {
+  try {
+    // Escape command for shell - need to escape backslashes and quotes
+    const escapedCmd = command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+
+    // If no window name provided, try to detect the first window
+    let targetWindow = windowName;
+    if (!targetWindow) {
+      try {
+        const windows = await listLocalSessionWindows(sessionName);
+        if (windows.length > 0) {
+          targetWindow = windows[0].name;
+        }
+      } catch {
+        // Fallback to default
+        targetWindow = "ssh";
+      }
+    }
+
+    // Use send-keys to send command as keystrokes, then Enter
+    // Format: {session}:{window} or {session}:{window}.{pane}
+    // Tmux uses 1-based indexing for panes. We target window by name
+    // If paneIndex is specified (not "0"), convert to 1-based and target the specific pane
+    // Otherwise, target just the window (tmux defaults to the active/first pane)
+    const target = paneIndex === "0"
+      ? `${sessionName}:${targetWindow}`
+      : `${sessionName}:${targetWindow}.${parseInt(paneIndex, 10)}`;
+    const sendCmd = `tmux send-keys -t "${target}" "${escapedCmd}" Enter`;
+
+    await execAsync(sendCmd, { timeout: 5000 });
+    return true;
+  } catch (error) {
+    console.error(
+      `[LocalTmux] Failed to send command to ${sessionName}:${paneIndex}:`,
+      error
+    );
+    return false;
+  }
+}
+
+/**
+ * Capture output from a local tmux pane
+ *
+ * This captures the current visible content of the pane, including
+ * the scrollback history.
+ *
+ * @param sessionName - Local tmux session name
+ * @param paneIndex - Pane index (default: "0")
+ * @param windowName - Window name (default: auto-detects first window)
+ * @returns Captured output or null if failed
+ */
+export async function captureLocalPane(
+  sessionName: string,
+  paneIndex: string = "0",
+  windowName?: string
+): Promise<string | null> {
+  try {
+    // If no window name provided, try to detect the first window
+    let targetWindow = windowName;
+    if (!targetWindow) {
+      try {
+        const windows = await listLocalSessionWindows(sessionName);
+        if (windows.length > 0) {
+          targetWindow = windows[0].name;
+        }
+      } catch {
+        targetWindow = "ssh";
+      }
+    }
+
+    // Format: {session}:{window} or {session}:{window}.{pane}
+    // Tmux uses 1-based indexing for panes
+    const target = paneIndex === "0"
+      ? `${sessionName}:${targetWindow}`
+      : `${sessionName}:${targetWindow}.${parseInt(paneIndex, 10)}`;
+    const { stdout } = await execAsync(
+      `tmux capture-pane -t "${target}" -p`,
+      { timeout: 5000 }
+    );
+
+    return stdout || null;
+  } catch (error) {
+    console.error(
+      `[LocalTmux] Failed to capture pane ${sessionName}:${paneIndex}:`,
+      error
+    );
+    return null;
+  }
+}
+
+/**
+ * Get scrollback/history from a local tmux pane
+ *
+ * @param sessionName - Local tmux session name
+ * @param paneIndex - Pane index (default: "0")
+ * @param lines - Number of lines to retrieve (default: -1 for all)
+ * @param windowName - Window name (default: auto-detects first window)
+ * @returns History content or null if failed
+ */
+export async function getLocalPaneHistory(
+  sessionName: string,
+  paneIndex: string = "0",
+  lines: number = -1,
+  windowName?: string
+): Promise<string | null> {
+  try {
+    // If no window name provided, try to detect the first window
+    let targetWindow = windowName;
+    if (!targetWindow) {
+      try {
+        const windows = await listLocalSessionWindows(sessionName);
+        if (windows.length > 0) {
+          targetWindow = windows[0].name;
+        }
+      } catch {
+        targetWindow = "ssh";
+      }
+    }
+
+    // Format: {session}:{window} or {session}:{window}.{pane}
+    // Tmux uses 1-based indexing for panes
+    const target = paneIndex === "0"
+      ? `${sessionName}:${targetWindow}`
+      : `${sessionName}:${targetWindow}.${parseInt(paneIndex, 10)}`;
+    const linesArg = lines > 0 ? `-S -${lines}` : "-S -";
+    const { stdout } = await execAsync(
+      `tmux capture-pane ${linesArg} -t "${target}" -p`,
+      { timeout: 10000 }
+    );
+
+    return stdout || null;
+  } catch (error) {
+    console.error(
+      `[LocalTmux] Failed to get history for ${sessionName}:${paneIndex}:`,
+      error
+    );
+    return null;
+  }
+}
+
+/**
+ * Kill a local tmux session
+ *
+ * @param sessionName - Session name to kill
+ * @returns True if session was killed successfully
+ */
+export async function killLocalSession(sessionName: string): Promise<boolean> {
+  try {
+    await execAsync(`tmux kill-session -t "${sessionName}" 2>/dev/null`, {
+      timeout: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get information about a local tmux session
+ *
+ * @param sessionName - Session name to query
+ * @returns Session information or null if session doesn't exist
+ */
+export async function getLocalSessionInfo(
+  sessionName: string
+): Promise<{
+  exists: boolean;
+  windows?: number;
+  panes?: number;
+} | null> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux display-message -t "${sessionName}" -p '#{session_windows} #{window_panes}' 2>/dev/null || echo ""`,
+      { timeout: 5000 }
+    );
+
+    if (!stdout || stdout.trim() === "") {
+      return { exists: false };
+    }
+
+    const [windows, panes] = stdout.trim().split(" ").map(Number);
+    return { exists: true, windows, panes };
+  } catch {
+    return { exists: false };
+  }
+}
+
+/**
+ * List all windows in a local tmux session
+ *
+ * @param sessionName - Local tmux session name
+ * @returns Array of window information
+ */
+export async function listLocalSessionWindows(
+  sessionName: string
+): Promise<Array<{ index: string; name: string; active: boolean }>> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux list-windows -t "${sessionName}" -F '#{window_index} #{window_name} #{window_active}' 2>/dev/null || echo ''`,
+      { timeout: 5000 }
+    );
+
+    if (!stdout || stdout.trim() === "") {
+      return [];
+    }
+
+    return stdout.trim().split("\n").map(line => {
+      const [index, name, active] = line.split(" ");
+      return { index, name, active: active === "1" };
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * List all panes in a local tmux session window
+ *
+ * @param sessionName - Local tmux session name
+ * @param windowIndex - Window index (default: "0")
+ * @returns Array of pane information
+ */
+export async function listLocalWindowPanes(
+  sessionName: string,
+  windowIndex: string = "0"
+): Promise<
+  Array<{ index: string; currentPath: string; pid: string; active: boolean }>
+> {
+  try {
+    const { stdout } = await execAsync(
+      `tmux list-panes -t "${sessionName}:${windowIndex}" -F '#{pane_index} #{pane_current_path} #{pane_pid} #{pane_active}' 2>/dev/null || echo ''`,
+      { timeout: 5000 }
+    );
+
+    if (!stdout || stdout.trim() === "") {
+      return [];
+    }
+
+    return stdout.trim().split("\n").map(line => {
+      const [index, currentPath, pid, active] = line.split(" ");
+      return { index, currentPath, pid, active: active === "1" };
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Split a pane horizontally or vertically in a local tmux session
+ *
+ * @param sessionName - Local tmux session name
+ * @param direction - Split direction: "h" (horizontal) or "v" (vertical)
+ * @param command - Optional command to run in the new pane
+ * @param windowName - Window name (default: auto-detects first window)
+ * @returns The new pane index or null if failed
+ */
+export async function splitLocalPane(
+  sessionName: string,
+  direction: "h" | "v" = "v",
+  command?: string,
+  windowName?: string
+): Promise<string | null> {
+  try {
+    // If no window name provided, try to detect the first window
+    let targetWindow = windowName;
+    if (!targetWindow) {
+      try {
+        const windows = await listLocalSessionWindows(sessionName);
+        if (windows.length > 0) {
+          targetWindow = windows[0].name;
+        }
+      } catch {
+        targetWindow = "ssh";
+      }
+    }
+
+    const target = `${sessionName}:${targetWindow}`;
+    const splitCmd = command
+      ? `tmux split-window -${direction} -t "${target}" -c "#{pane_current_path}" "${command}"`
+      : `tmux split-window -${direction} -t "${target}"`;
+
+    const { stdout } = await execAsync(splitCmd, { timeout: 10000 });
+
+    return stdout?.trim() || null;
+  } catch (error) {
+    console.error(`[LocalTmux] Failed to split pane in ${sessionName}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Cleanup old local tmux sessions
+ *
+ * @param config - Optional configuration (uses default age limit if not provided)
+ * @returns Object with cleaned count and errors
+ */
+export async function cleanupOldLocalSessions(
+  config: Partial<LocalTmuxConfig> = {}
+): Promise<{ cleaned: number; errors: string[] }> {
+  const fullConfig = { ...DEFAULT_CONFIG, ...config };
+  const errors: string[] = [];
+  let cleaned = 0;
+
+  try {
+    // Get all tmux sessions
+    const sessions = await listLocalSessions();
+
+    // Filter for MCP SSH sessions
+    const mcpSessions = sessions.filter(s => s.startsWith(fullConfig.sessionPrefix));
+
+    // Check age of each session by looking at socket file modification time
+    for (const sessionName of mcpSessions) {
+      try {
+        // Check session age by examining tmux socket file
+        // Tmux sockets are in /tmp/tmux-*/default
+        const ageCheckCmd = `
+          find /tmp -type s -name "*${sessionName}*" 2>/dev/null | head -1 | while read socket; do
+            if [ -n "$socket" ]; then
+              mtime=$(stat -f %m "$socket" 2>/dev/null || stat -c %Y "$socket" 2>/dev/null)
+              if [ -n "$mtime" ]; then
+                now=$(date +%s)
+                age=$((now - mtime))
+                age_ms=$((age * 1000))
+                echo "$age_ms"
+              fi
+            fi
+          done
+        `;
+
+        const { stdout } = await execAsync(ageCheckCmd, { timeout: 10000 });
+        const ageMs = parseInt(stdout.trim());
+
+        if (!isNaN(ageMs) && ageMs > fullConfig.sessionAgeLimit) {
+          console.log(
+            `[LocalTmux] Cleaning up old session "${sessionName}" (age: ${Math.round(ageMs / 86400000)} days)`
+          );
+          await killLocalSession(sessionName);
+          cleaned++;
+        }
+      } catch (err) {
+        errors.push(
+          `${sessionName}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+
+    return { cleaned, errors };
+  } catch (err) {
+    errors.push(
+      `Cleanup failed: ${err instanceof Error ? err.message : String(err)}`
+    );
+    return { cleaned, errors };
+  }
+}
+
+/**
+ * Get resource usage information for local tmux sessions
+ *
+ * @returns Resource usage summary
+ */
+export async function getLocalTmuxResourceUsage(): Promise<{
+  totalSessions: number;
+  mcpSessions: number;
+  estimatedMemoryMB: number;
+} | null> {
+  try {
+    // Get count of tmux sessions
+    const sessions = await listLocalSessions();
+    const mcpSessions = sessions.filter(s =>
+      s.startsWith(DEFAULT_CONFIG.sessionPrefix)
+    );
+
+    // Estimate memory: each session ~10MB base + scrollback buffer
+    const estimatedMemoryMB = mcpSessions.length * 11;
+
+    return {
+      totalSessions: sessions.length,
+      mcpSessions: mcpSessions.length,
+      estimatedMemoryMB,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Wait for a specific text to appear in the pane output
+ *
+ * @param sessionName - Local tmux session name
+ * @param text - Text to wait for
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+ * @param paneIndex - Pane index (default: "0")
+ * @param windowName - Window name (default: auto-detects first window)
+ * @returns True if text appeared, false if timeout
+ */
+export async function waitForTextInPane(
+  sessionName: string,
+  text: string,
+  timeoutMs: number = 30000,
+  paneIndex: string = "0",
+  windowName?: string
+): Promise<boolean> {
+  const startTime = Date.now();
+  const checkInterval = 500;
+
+  while (Date.now() - startTime < timeoutMs) {
+    const output = await captureLocalPane(sessionName, paneIndex, windowName);
+    if (output && output.includes(text)) {
+      return true;
+    }
+    await new Promise(resolve => setTimeout(resolve, checkInterval));
+  }
+
+  return false;
+}
+
+/**
+ * Switch to a specific window in a local tmux session
+ *
+ * @param sessionName - Local tmux session name
+ * @param windowIndex - Target window index
+ * @returns True if successful
+ */
+export async function switchLocalWindow(
+  sessionName: string,
+  windowIndex: string
+): Promise<boolean> {
+  try {
+    await execAsync(`tmux select-window -t "${sessionName}:${windowIndex}"`, {
+      timeout: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Switch to a specific pane in a local tmux session window
+ *
+ * @param sessionName - Local tmux session name
+ * @param paneIndex - Target pane index (e.g., "0", "1", "0.1" for window.pane)
+ * @returns True if successful
+ */
+export async function switchLocalPane(
+  sessionName: string,
+  paneIndex: string
+): Promise<boolean> {
+  try {
+    await execAsync(`tmux select-pane -t "${sessionName}:${paneIndex}"`, {
+      timeout: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Rename a window in a local tmux session
+ *
+ * @param sessionName - Local tmux session name
+ * @param windowIndex - Window index (default: "0")
+ * @param newName - New window name
+ * @returns True if successful
+ */
+export async function renameLocalWindow(
+  sessionName: string,
+  windowIndex: string,
+  newName: string
+): Promise<boolean> {
+  try {
+    await execAsync(
+      `tmux rename-window -t "${sessionName}:${windowIndex}" "${newName}"`,
+      { timeout: 5000 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Kill a specific pane in a local tmux session
+ *
+ * @param sessionName - Local tmux session name
+ * @param paneIndex - Pane index to kill
+ * @param windowName - Window name (default: auto-detects first window)
+ * @returns True if successful
+ */
+export async function killLocalPane(
+  sessionName: string,
+  paneIndex: string,
+  windowName?: string
+): Promise<boolean> {
+  try {
+    // If no window name provided, try to detect the first window
+    let targetWindow = windowName;
+    if (!targetWindow) {
+      try {
+        const windows = await listLocalSessionWindows(sessionName);
+        if (windows.length > 0) {
+          targetWindow = windows[0].name;
+        }
+      } catch {
+        targetWindow = "ssh";
+      }
+    }
+
+    // Format: {session}:{window} or {session}:{window}.{pane}
+    // Tmux uses 1-based indexing for panes
+    const target = paneIndex === "0"
+      ? `${sessionName}:${targetWindow}`
+      : `${sessionName}:${targetWindow}.${parseInt(paneIndex, 10)}`;
+    await execAsync(`tmux kill-pane -t "${target}"`, {
+      timeout: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get detailed information about all panes in a local session
+ *
+ * @param sessionName - Local tmux session name
+ * @returns Detailed session information or null
+ */
+export async function getDetailedLocalSessionInfo(
+  sessionName: string
+): Promise<{
+  exists: boolean;
+  windows: Array<{
+    index: string;
+    name: string;
+    active: boolean;
+    panes: Array<{
+      index: string;
+      currentPath: string;
+      pid: string;
+      active: boolean;
+    }>;
+  }>;
+} | null> {
+  try {
+    // First check if session exists
+    const exists = await hasLocalSession(sessionName);
+    if (!exists) {
+      return { exists: false, windows: [] };
+    }
+
+    // Get all windows
+    const windows = await listLocalSessionWindows(sessionName);
+
+    // Get panes for each window
+    const windowsWithPanes = await Promise.all(
+      windows.map(async window => {
+        const panes = await listLocalWindowPanes(sessionName, window.index);
+        return {
+          ...window,
+          panes,
+        };
+      })
+    );
+
+    return {
+      exists: true,
+      windows: windowsWithPanes,
+    };
+  } catch (error) {
+    console.error(
+      `[LocalTmux] Failed to get detailed info for ${sessionName}:`,
+      error
+    );
+    return null;
+  }
+}