@ebowwa/terminal 0.2.0

package/src/tmux-manager.ts

@@ -0,0 +1,962 @@
+/**
+ * Multi-Node Tmux Session Manager
+ * Provides unified management of tmux sessions across multiple VPS nodes
+ * Supports batch operations, session tracking, and parallel execution
+ */
+
+import type { SSHOptions } from "./types.js";
+import {
+  generateSessionName,
+  listTmuxSessions,
+  hasTmuxSession,
+  getTmuxSessionInfo,
+  getDetailedSessionInfo,
+  killTmuxSession,
+  sendCommandToPane,
+  splitPane,
+  listSessionWindows,
+  listWindowPanes,
+  capturePane,
+  getPaneHistory,
+  switchWindow,
+  switchPane,
+  renameWindow,
+  killPane,
+  cleanupOldTmuxSessions,
+  getTmuxResourceUsage,
+  ensureTmux,
+  createOrAttachTmuxSession,
+} from "./tmux.js";
+
+/**
+ * Represents a single node (server) in the cluster
+ */
+export interface Node {
+  /** Unique identifier (server ID from Hetzner) */
+  id: string;
+  /** Server name */
+  name: string;
+  /** IPv4 address */
+  ip: string;
+  /** IPv6 address (optional) */
+  ipv6?: string | null;
+  /** SSH user */
+  user: string;
+  /** SSH port */
+  port: number;
+  /** SSH key path (optional) */
+  keyPath?: string;
+  /** Node status */
+  status: "running" | "stopped" | "unreachable";
+  /** Metadata tags */
+  tags?: string[];
+  /** Datacenter location */
+  location?: string;
+}
+
+/**
+ * Represents a tmux session on a node
+ */
+export interface TmuxSession {
+  /** Session name */
+  name: string;
+  /** Node ID */
+  nodeId: string;
+  /** Number of windows */
+  windows?: number;
+  /** Number of panes */
+  panes?: number;
+  /** Session exists */
+  exists: boolean;
+}
+
+/**
+ * Detailed session information with windows and panes
+ */
+export interface DetailedTmuxSession extends TmuxSession {
+  windows: Array<{
+    index: string;
+    name: string;
+    active: boolean;
+    panes: Array<{
+      index: string;
+      currentPath: string;
+      pid: string;
+      active: boolean;
+    }>;
+  }>;
+}
+
+/**
+ * Batch operation result across multiple nodes
+ */
+export interface BatchOperationResult<T = any> {
+  /** Total nodes in batch */
+  total: number;
+  /** Successful operations */
+  successful: number;
+  /** Failed operations */
+  failed: number;
+  /** Results per node */
+  results: Array<{
+    nodeId: string;
+    nodeName: string;
+    success: boolean;
+    data?: T;
+    error?: string;
+  }>;
+}
+
+/**
+ * Options for creating a new tmux session
+ */
+export interface CreateSessionOptions {
+  /** Session name (auto-generated if not provided) */
+  sessionName?: string;
+  /** Initial working directory */
+  cwd?: string;
+  /** Initial command to run */
+  initialCommand?: string;
+  /** Window layout */
+  layout?: "even-horizontal" | "even-vertical" | "main-horizontal" | "main-vertical" | "tiled";
+}
+
+/**
+ * Options for batch command execution
+ */
+export interface BatchCommandOptions {
+  /** Command to execute */
+  command: string;
+  /** Target pane index (default: "0") */
+  paneIndex?: string;
+  /** Execute in parallel (default: true) */
+  parallel?: boolean;
+  /** Continue on error (default: true) */
+  continueOnError?: boolean;
+  /** Timeout per node (seconds) */
+  timeout?: number;
+}
+
+/**
+ * Options for multi-node session queries
+ */
+export interface SessionQueryOptions {
+  /** Filter by node IDs */
+  nodeIds?: string[];
+  /** Filter by tags */
+  tags?: string[];
+  /** Include detailed session info */
+  detailed?: boolean;
+  /** Include inactive sessions */
+  includeInactive?: boolean;
+}
+
+/**
+ * Multi-Node Tmux Session Manager
+ * Manages tmux sessions across multiple VPS nodes
+ */
+export class TmuxSessionManager {
+  private nodes: Map<string, Node> = new Map();
+  private sessionCache: Map<string, TmuxSession[]> = new Map();
+  private cacheTimeout: number = 30000; // 30 seconds
+  private lastCacheUpdate: Map<string, number> = new Map();
+
+  /**
+   * Add or update a node in the manager
+   */
+  addNode(node: Node): void {
+    this.nodes.set(node.id, { ...node });
+    // Invalidate cache for this node
+    this.sessionCache.delete(node.id);
+    this.lastCacheUpdate.delete(node.id);
+  }
+
+  /**
+   * Remove a node from the manager
+   */
+  removeNode(nodeId: string): void {
+    this.nodes.delete(nodeId);
+    this.sessionCache.delete(nodeId);
+    this.lastCacheUpdate.delete(nodeId);
+  }
+
+  /**
+   * Get a node by ID
+   */
+  getNode(nodeId: string): Node | undefined {
+    return this.nodes.get(nodeId);
+  }
+
+  /**
+   * Get all nodes
+   */
+  getAllNodes(): Node[] {
+    return Array.from(this.nodes.values());
+  }
+
+  /**
+   * Get nodes by tag
+   */
+  getNodesByTag(tag: string): Node[] {
+    return this.getAllNodes().filter((node) => node.tags?.includes(tag));
+  }
+
+  /**
+   * Get active nodes (running and reachable)
+   */
+  getActiveNodes(): Node[] {
+    return this.getAllNodes().filter((node) => node.status === "running");
+  }
+
+  /**
+   * Get SSH options for a node
+   */
+  private getSSHOptions(node: Node): SSHOptions {
+    return {
+      host: node.ip,
+      user: node.user,
+      port: node.port,
+      keyPath: node.keyPath,
+      timeout: 30,
+    };
+  }
+
+  /**
+   * Invalidate session cache for a node or all nodes
+   */
+  invalidateCache(nodeId?: string): void {
+    if (nodeId) {
+      this.sessionCache.delete(nodeId);
+      this.lastCacheUpdate.delete(nodeId);
+    } else {
+      this.sessionCache.clear();
+      this.lastCacheUpdate.clear();
+    }
+  }
+
+  /**
+   * Check if cache is valid for a node
+   */
+  private isCacheValid(nodeId: string): boolean {
+    const lastUpdate = this.lastCacheUpdate.get(nodeId);
+    if (!lastUpdate) return false;
+    return Date.now() - lastUpdate < this.cacheTimeout;
+  }
+
+  /**
+   * Create a new tmux session on a node
+   */
+  async createSession(
+    nodeId: string,
+    options: CreateSessionOptions = {}
+  ): Promise<{ success: boolean; sessionName?: string; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node) {
+      return { success: false, error: `Node ${nodeId} not found` };
+    }
+
+    if (node.status !== "running") {
+      return { success: false, error: `Node ${nodeId} is not running` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+
+      // Ensure tmux is installed
+      const tmuxCheck = await ensureTmux(sshOpts);
+      if (!tmuxCheck.success) {
+        return { success: false, error: tmuxCheck.message };
+      }
+
+      // Generate session name if not provided
+      const sessionName = options.sessionName || generateSessionName(node.ip, node.user);
+
+      // Check if session already exists
+      const exists = await hasTmuxSession(sessionName, sshOpts);
+      if (exists) {
+        return { success: true, sessionName };
+      }
+
+      // Create new session with tmux command
+      const createCmd = options.initialCommand
+        ? `tmux new-session -d -s "${sessionName}" -n "main" "${options.initialCommand}"`
+        : `tmux new-session -d -s "${sessionName}" -n "main"`;
+
+      const { getSSHPool } = await import("./pool.js");
+      const pool = getSSHPool();
+      await pool.exec(createCmd, sshOpts);
+
+      // Set initial options
+      if (options.cwd) {
+        await pool.exec(`tmux set-option -t "${sessionName}" default-path "${options.cwd}"`, sshOpts);
+      }
+
+      if (options.layout) {
+        await pool.exec(`tmux select-layout -t "${sessionName}" ${options.layout}`, sshOpts);
+      }
+
+      // Invalidate cache
+      this.invalidateCache(nodeId);
+
+      return { success: true, sessionName };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Attach to a tmux session on a node (returns SSH command args)
+   */
+  async attachSession(
+    nodeId: string,
+    sessionName?: string
+  ): Promise<{ success: true; sshArgs: string[]; sessionName: string } | { success: false; error: string }> {
+    const node = this.getNode(nodeId);
+    if (!node) {
+      return { success: false, error: `Node ${nodeId} not found` };
+    }
+
+    if (node.status !== "running") {
+      return { success: false, error: `Node ${nodeId} is not running` };
+    }
+
+    try {
+      const result = await createOrAttachTmuxSession(
+        node.ip,
+        node.user,
+        node.keyPath,
+        { sessionName }
+      );
+
+      return {
+        success: true,
+        sshArgs: result.sshArgs,
+        sessionName: result.sessionName,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * List all sessions across nodes
+   */
+  async listSessions(options: SessionQueryOptions = {}): Promise<TmuxSession[]> {
+    const nodes = options.nodeIds
+      ? options.nodeIds.map((id) => this.getNode(id)).filter(Boolean) as Node[]
+      : options.tags
+      ? options.tags.flatMap((tag) => this.getNodesByTag(tag))
+      : this.getActiveNodes();
+
+    const allSessions: TmuxSession[] = [];
+
+    for (const node of nodes) {
+      if (node.status !== "running") continue;
+
+      // Use cache if valid
+      if (this.isCacheValid(node.id) && this.sessionCache.has(node.id)) {
+        allSessions.push(...this.sessionCache.get(node.id)!);
+        continue;
+      }
+
+      try {
+        const sshOpts = this.getSSHOptions(node);
+        const sessionNames = await listTmuxSessions(sshOpts);
+
+        const sessions: TmuxSession[] = await Promise.all(
+          sessionNames.map(async (name) => {
+            const info = await getTmuxSessionInfo(name, sshOpts);
+            return {
+              name,
+              nodeId: node.id,
+              windows: info?.windows,
+              panes: info?.panes,
+              exists: info?.exists ?? true,
+            };
+          })
+        );
+
+        // Update cache
+        this.sessionCache.set(node.id, sessions);
+        this.lastCacheUpdate.set(node.id, Date.now());
+
+        allSessions.push(...sessions);
+      } catch {
+        // Node unreachable, skip
+        continue;
+      }
+    }
+
+    return allSessions;
+  }
+
+  /**
+   * Get detailed session information
+   */
+  async getDetailedSession(
+    nodeId: string,
+    sessionName: string
+  ): Promise<DetailedTmuxSession | null> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return null;
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const info = await getDetailedSessionInfo(sessionName, sshOpts);
+
+      if (!info || !info.exists) {
+        return null;
+      }
+
+      return {
+        name: sessionName,
+        nodeId: node.id,
+        exists: true,
+        windows: info.windows,
+      };
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Kill a session on a node
+   */
+  async killSession(nodeId: string, sessionName: string): Promise<{ success: boolean; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node) {
+      return { success: false, error: `Node ${nodeId} not found` };
+    }
+
+    if (node.status !== "running") {
+      return { success: false, error: `Node ${nodeId} is not running` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const killed = await killTmuxSession(sessionName, sshOpts);
+
+      // Invalidate cache
+      this.invalidateCache(nodeId);
+
+      return { success: killed };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Send a command to a specific session on a node
+   */
+  async sendCommand(
+    nodeId: string,
+    sessionName: string,
+    command: string,
+    paneIndex: string = "0"
+  ): Promise<{ success: boolean; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await sendCommandToPane(sessionName, command, paneIndex, sshOpts);
+      return { success: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Send command to multiple nodes (batch operation)
+   */
+  async sendCommandToNodes(
+    nodeIds: string[],
+    sessionName: string,
+    command: string,
+    options: BatchCommandOptions = {}
+  ): Promise<BatchOperationResult> {
+    const { parallel = true, continueOnError = true, paneIndex = "0", timeout = 30 } = options;
+
+    const nodes = nodeIds.map((id) => this.getNode(id)).filter(Boolean) as Node[];
+    const results: BatchOperationResult["results"] = [];
+    let successful = 0;
+    let failed = 0;
+
+    const executeCommand = async (node: Node) => {
+      if (node.status !== "running") {
+        failed++;
+        return {
+          nodeId: node.id,
+          nodeName: node.name,
+          success: false,
+          error: `Node is ${node.status}`,
+        };
+      }
+
+      try {
+        const sshOpts = { ...this.getSSHOptions(node), timeout };
+        const result = await sendCommandToPane(sessionName, command, paneIndex, sshOpts);
+
+        if (result) {
+          successful++;
+          return {
+            nodeId: node.id,
+            nodeName: node.name,
+            success: true,
+          };
+        } else {
+          failed++;
+          return {
+            nodeId: node.id,
+            nodeName: node.name,
+            success: false,
+            error: "Failed to send command",
+          };
+        }
+      } catch (error) {
+        failed++;
+        return {
+          nodeId: node.id,
+          nodeName: node.name,
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    };
+
+    if (parallel) {
+      const resultsArray = await Promise.allSettled(nodes.map(executeCommand));
+      resultsArray.forEach((result) => {
+        if (result.status === "fulfilled") {
+          results.push(result.value);
+        } else {
+          results.push({
+            nodeId: "unknown",
+            nodeName: "unknown",
+            success: false,
+            error: String(result.reason),
+          });
+        }
+      });
+    } else {
+      for (const node of nodes) {
+        try {
+          const result = await executeCommand(node);
+          results.push(result);
+          if (!result.success && !continueOnError) {
+            break;
+          }
+        } catch (error) {
+          failed++;
+          results.push({
+            nodeId: node.id,
+            nodeName: node.name,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          if (!continueOnError) {
+            break;
+          }
+        }
+      }
+    }
+
+    return {
+      total: nodes.length,
+      successful,
+      failed,
+      results,
+    };
+  }
+
+  /**
+   * Split a pane in a session
+   */
+  async splitPaneOnNode(
+    nodeId: string,
+    sessionName: string,
+    direction: "h" | "v" = "v",
+    command: string | null = null,
+    windowIndex: string = "0"
+  ): Promise<{ success: boolean; newPaneIndex?: string; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await splitPane(sessionName, direction, command, sshOpts);
+
+      return {
+        success: result !== null,
+        newPaneIndex: result || undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Capture pane output from a session
+   */
+  async capturePaneOutput(
+    nodeId: string,
+    sessionName: string,
+    paneIndex: string = "0"
+  ): Promise<{ success: boolean; output?: string; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const output = await capturePane(sessionName, paneIndex, sshOpts);
+
+      return {
+        success: output !== null,
+        output: output || undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Get pane history (scrollback buffer)
+   */
+  async getPaneHistory(
+    nodeId: string,
+    sessionName: string,
+    paneIndex: string = "0",
+    lines: number = -1
+  ): Promise<{ success: boolean; history?: string; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const history = await getPaneHistory(sessionName, paneIndex, lines, sshOpts);
+
+      return {
+        success: history !== null,
+        history: history || undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * List windows in a session
+   */
+  async listWindows(
+    nodeId: string,
+    sessionName: string
+  ): Promise<{ success: boolean; windows?: Array<{ index: string; name: string; active: boolean }>; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const windows = await listSessionWindows(sessionName, sshOpts);
+
+      return {
+        success: true,
+        windows,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * List panes in a window
+   */
+  async listPanes(
+    nodeId: string,
+    sessionName: string,
+    windowIndex: string = "0"
+  ): Promise<{
+    success: boolean;
+    panes?: Array<{ index: string; currentPath: string; pid: string; active: boolean }>;
+    error?: string;
+  }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const panes = await listWindowPanes(sessionName, windowIndex, sshOpts);
+
+      return {
+        success: true,
+        panes,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Switch to a different window in a session
+   */
+  async switchToWindow(
+    nodeId: string,
+    sessionName: string,
+    windowIndex: string
+  ): Promise<{ success: boolean; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await switchWindow(sessionName, windowIndex, sshOpts);
+
+      return { success: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Switch to a different pane in a session
+   */
+  async switchToPane(
+    nodeId: string,
+    sessionName: string,
+    paneIndex: string
+  ): Promise<{ success: boolean; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await switchPane(sessionName, paneIndex, sshOpts);
+
+      return { success: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Rename a window in a session
+   */
+  async renameWindowInSession(
+    nodeId: string,
+    sessionName: string,
+    windowIndex: string,
+    newName: string
+  ): Promise<{ success: boolean; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await renameWindow(sessionName, windowIndex, newName, sshOpts);
+
+      return { success: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Kill a pane in a session
+   */
+  async killPaneInSession(
+    nodeId: string,
+    sessionName: string,
+    paneIndex: string
+  ): Promise<{ success: boolean; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await killPane(sessionName, paneIndex, sshOpts);
+
+      return { success: result };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Cleanup old sessions on a node
+   */
+  async cleanupOldSessions(
+    nodeId: string,
+    ageLimitMs: number = 30 * 24 * 60 * 60 * 1000
+  ): Promise<{ success: boolean; cleaned?: number; errors?: string[] }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const result = await cleanupOldTmuxSessions(sshOpts, { sessionAgeLimit: ageLimitMs });
+
+      // Invalidate cache
+      this.invalidateCache(nodeId);
+
+      return {
+        success: true,
+        cleaned: result.cleaned,
+        errors: result.errors,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Get resource usage for sessions on a node
+   */
+  async getResourceUsage(
+    nodeId: string
+  ): Promise<{ success: boolean; usage?: { totalSessions: number; codespacesSessions: number; estimatedMemoryMB: number }; error?: string }> {
+    const node = this.getNode(nodeId);
+    if (!node || node.status !== "running") {
+      return { success: false, error: node ? `Node ${nodeId} is not running` : `Node ${nodeId} not found` };
+    }
+
+    try {
+      const sshOpts = this.getSSHOptions(node);
+      const usage = await getTmuxResourceUsage(sshOpts);
+
+      return {
+        success: usage !== null,
+        usage: usage || undefined,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  /**
+   * Get summary statistics across all nodes
+   */
+  async getSummary(): Promise<{
+    totalNodes: number;
+    activeNodes: number;
+    totalSessions: number;
+    totalMemoryUsageMB: number;
+    nodesWithSessions: number;
+  }> {
+    const nodes = this.getActiveNodes();
+    const sessions = await this.listSessions();
+
+    let totalMemoryUsageMB = 0;
+    const nodesWithSessions = new Set<string>();
+
+    // Group sessions by node
+    for (const session of sessions) {
+      nodesWithSessions.add(session.nodeId);
+    }
+
+    // Calculate memory usage per node
+    for (const node of nodes) {
+      const usage = await this.getResourceUsage(node.id);
+      if (usage.success && usage.usage) {
+        totalMemoryUsageMB += usage.usage.estimatedMemoryMB;
+      }
+    }
+
+    return {
+      totalNodes: this.nodes.size,
+      activeNodes: nodes.length,
+      totalSessions: sessions.length,
+      totalMemoryUsageMB,
+      nodesWithSessions: nodesWithSessions.size,
+    };
+  }
+}
+
+/**
+ * Global singleton instance
+ */
+let globalManager: TmuxSessionManager | null = null;
+
+/**
+ * Get the global tmux session manager instance
+ */
+export function getTmuxManager(): TmuxSessionManager {
+  if (!globalManager) {
+    globalManager = new TmuxSessionManager();
+  }
+  return globalManager;
+}
+
+/**
+ * Reset the global manager (for testing)
+ */
+export function resetTmuxManager(): void {
+  globalManager = null;
+}