kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

plugins/tmux_plugin.py

@@ -15,14 +15,20 @@ from typing import Dict, Any, List, Optional
 from dataclasses import dataclass, field
 from datetime import datetime
 
+from core.io.visual_effects import AgnosterSegment
+
 logger = logging.getLogger(__name__)
 
+# Default socket name for kollabor's isolated tmux server
+DEFAULT_KOLLABOR_SOCKET = "kollabor"
+
 
 @dataclass
 class TmuxSession:
     """Represents a managed tmux session."""
     name: str
     command: str
+    tmux_cmd: callable  # Function to build tmux commands with correct socket
     created_at: datetime = field(default_factory=datetime.now)
     pid: Optional[int] = None
 
@@ -30,7 +36,7 @@ class TmuxSession:
         """Check if the tmux session is still running."""
         try:
             result = subprocess.run(
-                ["tmux", "has-session", "-t", self.name],
+                self.tmux_cmd("has-session", "-t", self.name),
                 capture_output=True
             )
             return result.returncode == 0
@@ -41,13 +47,12 @@ class TmuxSession:
 class TmuxPlugin:
     """Plugin for tmux session management and live viewing."""
 
-    def __init__(self, name: str = "tmux", state_manager=None, event_bus=None,
+    def __init__(self, name: str = "tmux", event_bus=None,
                  renderer=None, config=None):
         """Initialize the tmux plugin.
 
         Args:
             name: Plugin name.
-            state_manager: State management system.
             event_bus: Event bus for hook registration.
             renderer: Terminal renderer.
             config: Configuration manager.
@@ -58,7 +63,6 @@ class TmuxPlugin:
         self.enabled = True
 
         self.sessions: Dict[str, TmuxSession] = {}
-        self.state_manager = state_manager
         self.event_bus = event_bus
         self.renderer = renderer
         self.config = config
@@ -71,6 +75,19 @@ class TmuxPlugin:
 
         self.logger = logger
 
+    def _tmux_cmd(self, *args: str) -> List[str]:
+        """Build a tmux command with optional socket name.
+
+        If use_separate_server is enabled (default), uses a dedicated
+        kollabor tmux server. Otherwise uses the user's main tmux server.
+        """
+        use_separate = self.config.get("plugins.tmux.use_separate_server", True) if self.config else True
+        socket_name = self.config.get("plugins.tmux.socket_name", DEFAULT_KOLLABOR_SOCKET) if self.config else DEFAULT_KOLLABOR_SOCKET
+
+        if use_separate:
+            return ["tmux", "-L", socket_name] + list(args)
+        return ["tmux"] + list(args)
+
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
         """Get default configuration for tmux plugin."""
@@ -79,8 +96,10 @@ class TmuxPlugin:
                 "tmux": {
                     "enabled": True,
                     "show_status": True,
-                    "refresh_rate": 0.1,  # Live view refresh rate in seconds
-                    "default_shell": "/bin/bash"
+                    "refresh_rate": 0.5,  # Live view refresh rate in seconds
+                    "capture_lines": 200,  # Number of lines to capture from pane history
+                    "use_separate_server": True,  # Use dedicated tmux server
+                    "socket_name": DEFAULT_KOLLABOR_SOCKET  # Socket name for separate server
                 }
             }
         }
@@ -129,19 +148,26 @@ class TmuxPlugin:
     def _register_commands(self):
         """Register tmux commands with the command registry."""
         from core.events.models import (
-            CommandDefinition, CommandMode, CommandCategory
+            CommandDefinition, CommandMode, CommandCategory, SubcommandInfo
         )
 
         # /terminal - manage tmux sessions
         terminal_cmd = CommandDefinition(
             name="terminal",
-            description="Manage tmux sessions (new/view/list/kill)",
+            description="Manage terminal sessions (new/view/list/kill)",
             handler=self._handle_tmux_command,
             plugin_name=self.name,
-            category=CommandCategory.SYSTEM,
+            category=CommandCategory.CUSTOM,  # Plugin command
             mode=CommandMode.INSTANT,
             aliases=["term", "tmux", "t"],
-            icon="[>_]"
+            icon="[>_]",
+            subcommands=[
+                SubcommandInfo("new", "<name> <cmd>", "Create session running command"),
+                SubcommandInfo("view", "[name]", "Live view session (default)"),
+                SubcommandInfo("list", "", "List all sessions"),
+                SubcommandInfo("kill", "<name>", "Kill a session"),
+                SubcommandInfo("attach", "<name>", "Attach (exits kollabor)"),
+            ]
         )
         self.command_registry.register_command(terminal_cmd)
 
@@ -194,6 +220,8 @@ class TmuxPlugin:
         """Get help text for terminal command."""
         return """Terminal Session Manager
 
+By default, sessions use a dedicated tmux server (configurable).
+
 Usage:
   /terminal new <name> <command>  Create new session running command
   /terminal view [name]           Live view session (</> to cycle)
@@ -207,6 +235,11 @@ Examples:
   /terminal view
   /terminal kill myserver
 
+To attach directly (with default separate server):
+  tmux -L kollabor attach -t <session_name>
+
+To use your main tmux instead, disable "Use Separate Server" in config.
+
 Aliases: /t, /term, /tmux"""
 
     async def _handle_new_session(self, args: List[str]) -> "CommandResult":
@@ -232,9 +265,10 @@ Aliases: /t, /term, /tmux"""
             )
 
         try:
-            # Create detached tmux session with interactive bash shell
+            # Create detached tmux session with user's default shell
+            # (tmux uses $SHELL or user's login shell by default)
             result = subprocess.run(
-                ["tmux", "new-session", "-d", "-s", session_name, "bash", "-i"],
+                self._tmux_cmd("new-session", "-d", "-s", session_name),
                 capture_output=True,
                 text=True
             )
@@ -249,7 +283,7 @@ Aliases: /t, /term, /tmux"""
             # Send the command to the new session (if provided)
             if command:
                 send_result = subprocess.run(
-                    ["tmux", "send-keys", "-t", session_name, command, "Enter"],
+                    self._tmux_cmd("send-keys", "-t", session_name, command, "Enter"),
                     capture_output=True,
                     text=True
                 )
@@ -260,7 +294,8 @@ Aliases: /t, /term, /tmux"""
             # Track the session
             self.sessions[session_name] = TmuxSession(
                 name=session_name,
-                command=command or "bash"
+                command=command or "bash",
+                tmux_cmd=self._tmux_cmd
             )
 
             msg = f"Created session '{session_name}'"
@@ -308,13 +343,23 @@ Aliases: /t, /term, /tmux"""
             from core.ui.live_modal_renderer import LiveModalConfig
             from core.events.models import EventType
 
+            # Get terminal height for viewport calculation
+            terminal_height = 40  # Default fallback
+            if self.renderer and hasattr(self.renderer, 'terminal_state'):
+                _, terminal_height = self.renderer.terminal_state.get_size()
+            # Capture enough lines to fill the modal content area
+            # Modal height is roughly terminal_height - 4, minus borders/header/footer
+            # Use terminal_height - 6 to be safe
+            viewport_lines = max(10, terminal_height-8)
+
             # Content generator - uses self._current_session for dynamic switching
             async def get_tmux_content() -> List[str]:
                 # Show session name as header line
                 sessions = self._get_all_tmux_sessions()
                 session_idx = sessions.index(self._current_session) + 1 if self._current_session in sessions else 1
                 header = f"[Session: {self._current_session}] ({session_idx}/{len(sessions)})"
-                content = self._capture_tmux_pane(self._current_session)
+                # Capture only the newest lines that fit in viewport
+                content = self._capture_tmux_pane(self._current_session, max_lines=viewport_lines)
                 return [header, "─" * len(header)] + content
 
             # Input callback for passthrough
@@ -326,7 +371,7 @@ Aliases: /t, /term, /tmux"""
                 if key_press.code == 8776:
                     try:
                         subprocess.run(
-                            ["tmux", "kill-session", "-t", self._current_session],
+                            self._tmux_cmd("kill-session", "-t", self._current_session),
                             capture_output=True,
                             text=True,
                             timeout=2
@@ -433,35 +478,44 @@ Aliases: /t, /term, /tmux"""
                 display_type="error"
             )
 
-    def _capture_tmux_pane(self, session_name: str) -> List[str]:
-        """Capture current content of a tmux pane."""
+    def _capture_tmux_pane(self, session_name: str, max_lines: Optional[int] = None) -> List[str]:
+        """Capture current content of a tmux pane.
+
+        Args:
+            session_name: Name of the tmux session
+            max_lines: Maximum lines to return. Returns newest content from bottom.
+
+        Returns:
+            List of cleaned content lines from newest to oldest.
+        """
         try:
-            # Capture only the last 5 lines to reduce overhead
+            # Capture more lines than we need, then take from the end
+            capture_lines = self.config.get("plugins.tmux.capture_lines", 500) if self.config else 500
+            # Capture from the end of the pane history
             result = subprocess.run(
-                ["tmux", "capture-pane", "-p", "-S", "-5", "-t", session_name],
+                self._tmux_cmd("capture-pane", "-p", "-e", "-S", f"-{capture_lines}", "-t", session_name),
                 capture_output=True,
                 text=True,
-                timeout=2  # Add timeout to prevent hanging
+                timeout=2
             )
             if result.returncode == 0:
-                # Split on \n and handle empty lines properly
-                content = result.stdout
-                # Remove trailing empty lines but keep internal empty lines
-                while content.endswith('\n'):
-                    content = content[:-1]
+                import re
+                lines = result.stdout.rstrip('\n').split('\n')
 
-                lines = content.split('\n')
-
-                # Clean up captured content for display
+                # Strip ANSI codes but keep all lines including empty ones
                 cleaned = []
                 for line in lines:
-                    # Strip ANSI escape sequences and trailing whitespace
-                    import re
                     line = re.sub(r'\x1b\[[0-9;]*m', '', line)  # Remove ANSI colors
                     line = line.rstrip()
-                    # Only add non-empty lines or empty lines that have meaningful content
-                    if line or (cleaned and cleaned[-1] and not cleaned[-1].isspace()):
-                        cleaned.append(line)
+                    cleaned.append(line)
+
+                # Remove trailing empty lines from the END (not beginning)
+                while cleaned and not cleaned[-1]:
+                    cleaned.pop()
+
+                # Return only the newest lines that fit in viewport (from the end)
+                if max_lines and len(cleaned) > max_lines:
+                    return cleaned[-max_lines:]
                 return cleaned
             else:
                 return [f"Error capturing pane: {result.stderr}"]
@@ -474,7 +528,7 @@ Aliases: /t, /term, /tmux"""
         """Send keys to a tmux session."""
         try:
             subprocess.run(
-                ["tmux", "send-keys", "-t", session_name, keys],
+                self._tmux_cmd("send-keys", "-t", session_name, keys),
                 capture_output=True
             )
         except Exception as e:
@@ -490,7 +544,7 @@ Aliases: /t, /term, /tmux"""
         if not all_sessions:
             return CommandResult(
                 success=True,
-                message="No tmux sessions found. Use '/tmux new <name> <command>' to create one.",
+                message="No tmux sessions found. Use '/terminal new <name> <command>' to create one.",
                 display_type="info"
             )
 
@@ -520,7 +574,7 @@ Aliases: /t, /term, /tmux"""
         if not args:
             return CommandResult(
                 success=False,
-                message="Usage: /tmux kill <session_name>",
+                message="Usage: /terminal kill <session_name>",
                 display_type="error"
             )
 
@@ -528,7 +582,7 @@ Aliases: /t, /term, /tmux"""
 
         try:
             result = subprocess.run(
-                ["tmux", "kill-session", "-t", session_name],
+                self._tmux_cmd("kill-session", "-t", session_name),
                 capture_output=True,
                 text=True
             )
@@ -563,7 +617,7 @@ Aliases: /t, /term, /tmux"""
         if not args:
             return CommandResult(
                 success=False,
-                message="Usage: /tmux attach <session_name>",
+                message="Usage: /terminal attach <session_name>",
                 display_type="error"
             )
 
@@ -576,9 +630,18 @@ Aliases: /t, /term, /tmux"""
                 display_type="error"
             )
 
+        # Build attach command based on whether using separate server
+        use_separate = self.config.get("plugins.tmux.use_separate_server", True) if self.config else True
+        socket_name = self.config.get("plugins.tmux.socket_name", DEFAULT_KOLLABOR_SOCKET) if self.config else DEFAULT_KOLLABOR_SOCKET
+
+        if use_separate:
+            attach_cmd = f"tmux -L {socket_name} attach -t {session_name}"
+        else:
+            attach_cmd = f"tmux attach -t {session_name}"
+
         return CommandResult(
             success=True,
-            message=f"To attach to '{session_name}', exit kollabor and run:\n  tmux attach -t {session_name}",
+            message=f"To attach to '{session_name}', exit kollabor and run:\n  {attach_cmd}",
             display_type="info"
         )
 
@@ -586,7 +649,7 @@ Aliases: /t, /term, /tmux"""
         """Check if a tmux session exists."""
         try:
             result = subprocess.run(
-                ["tmux", "has-session", "-t", session_name],
+                self._tmux_cmd("has-session", "-t", session_name),
                 capture_output=True
             )
             return result.returncode == 0
@@ -631,7 +694,7 @@ Aliases: /t, /term, /tmux"""
         """Get list of all existing tmux sessions."""
         try:
             result = subprocess.run(
-                ["tmux", "list-sessions", "-F", "#{session_name}"],
+                self._tmux_cmd("list-sessions", "-F", "#{session_name}"),
                 capture_output=True,
                 text=True,
                 check=True
@@ -655,7 +718,7 @@ Aliases: /t, /term, /tmux"""
         """Discover existing tmux sessions (optional bootstrap)."""
         try:
             result = subprocess.run(
-                ["tmux", "list-sessions", "-F", "#{session_name}"],
+                self._tmux_cmd("list-sessions", "-F", "#{session_name}"),
                 capture_output=True,
                 text=True
             )
@@ -702,53 +765,45 @@ Aliases: /t, /term, /tmux"""
             logger.error(f"Failed to register tmux status view: {e}")
 
     def _get_tmux_sessions_content(self) -> List[str]:
-        """Get tmux sessions content for status view."""
+        """Get tmux sessions content for status view (agnoster style)."""
         try:
+            seg = AgnosterSegment()
+
             if not self.enabled:
-                return ["Tmux: Disabled"]
+                seg.add_neutral("Tmux: Disabled", "dark")
+                return [seg.render()]
 
-            # Get all tmux sessions (both managed and discovered)
+            # Get all tmux sessions
             all_sessions = self._get_all_tmux_sessions()
-
-            if not all_sessions:
-                return ["Sessions: 0 active"]
-
-            lines = []
             session_count = len(all_sessions)
 
-            # Header line
-            lines.append(f"Sessions: {session_count} active | /terminal to view")
-
-            # Display sessions in 3-column layout
-            max_display = 9  # Show max 9 sessions (3 rows x 3 columns)
-            display_sessions = all_sessions[:max_display]
-
-            # Group into rows of 3
-            rows = []
-            for i in range(0, len(display_sessions), 3):
-                row = display_sessions[i:i+3]
-                rows.append(row)
+            if session_count == 0:
+                seg.add_lime("Tmux", "dark")
+                seg.add_neutral("No sessions", "mid")
+                return [seg.render()]
 
-            # Format each row
-            for row in rows:
-                # Pad row to 3 columns
-                while len(row) < 3:
-                    row.append("")
+            # Build agnoster bar: Tmux | count | session names | hint
+            seg.add_lime("Tmux", "dark")
+            seg.add_cyan(f"{session_count} active", "dark")
 
-                # Format with fixed width columns
-                formatted_row = f"{row[0]:<30}{row[1]:<30}{row[2]:<30}"
-                lines.append(formatted_row.rstrip())
+            # Show first few session names
+            max_show = 3
+            if all_sessions:
+                names = all_sessions[:max_show]
+                names_str = " | ".join(names)
+                if session_count > max_show:
+                    names_str += f" +{session_count - max_show}"
+                seg.add_lime(names_str)
 
-            # Show overflow count if there are more sessions
-            if session_count > max_display:
-                overflow = session_count - max_display
-                lines.append(f"({overflow} more...)")
+            seg.add_neutral("/terminal", "mid")
 
-            return lines
+            return [seg.render()]
 
         except Exception as e:
             logger.error(f"Error getting tmux sessions content: {e}")
-            return ["Tmux: Error"]
+            seg = AgnosterSegment()
+            seg.add_neutral("Tmux: Error", "dark")
+            return [seg.render()]
 
     def get_status_line(self) -> Dict[str, List[str]]:
         """Get status line (no longer used - using status view instead)."""
@@ -774,7 +829,7 @@ Aliases: /t, /term, /tmux"""
     def get_config_widgets() -> Optional[Dict[str, Any]]:
         """Get configuration widgets for the config modal."""
         return {
-            "title": "Tmux Settings",
+            "title": "Terminal Settings",
             "widgets": [
                 {
                     "type": "checkbox",
@@ -790,6 +845,27 @@ Aliases: /t, /term, /tmux"""
                     "max_value": 1000,
                     "step": 50,
                     "help": "Live view refresh rate in milliseconds"
+                },
+                {
+                    "type": "slider",
+                    "label": "Capture Lines",
+                    "config_path": "plugins.tmux.capture_lines",
+                    "min_value": 10,
+                    "max_value": 1000,
+                    "step": 10,
+                    "help": "Number of lines to capture from pane history"
+                },
+                {
+                    "type": "checkbox",
+                    "label": "Use Separate Server",
+                    "config_path": "plugins.tmux.use_separate_server",
+                    "help": "Use dedicated tmux server (isolated from your main tmux)"
+                },
+                {
+                    "type": "text_input",
+                    "label": "Socket Name",
+                    "config_path": "plugins.tmux.socket_name",
+                    "help": "Socket name for separate tmux server (default: kollabor)"
                 }
             ]
         }