aline-ai 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

realign/dashboard/widgets/terminal_panel.py

@@ -11,7 +11,6 @@ import asyncio
 import os
 import re
 import shlex
-import subprocess
 from pathlib import Path
 from typing import Callable
 
@@ -295,30 +294,15 @@ class TerminalPanel(Container, can_focus=True):
         controls_enabled = self.supported()
         with Horizontal(classes="summary"):
             yield Button(
-                "＋ Claude",
-                id="new-cc",
+                "＋ Create",
+                id="new-agent",
                 variant="primary",
                 disabled=not controls_enabled,
             )
-            yield Button(
-                "＋ Codex",
-                id="new-codex",
-                variant="primary",
-                disabled=not controls_enabled,
-            )
-            yield Button(
-                "＋ Opencode",
-                id="new-opencode",
-                variant="primary",
-                disabled=not controls_enabled,
-            )
-            yield Button("＋ zsh", id="new-zsh", variant="primary", disabled=not controls_enabled)
-            yield Button("↻", id="refresh")
-            yield Static("", id="status", classes="status")
         with Vertical(id="terminals", classes="list"):
             if controls_enabled:
                 yield Static(
-                    "No terminals yet. Click 'New cc' / 'New codex' to open the right pane."
+                    "No terminals yet. Click 'Create' to open a new agent terminal."
                 )
             else:
                 yield Static(self._support_message())
@@ -373,21 +357,15 @@ class TerminalPanel(Container, can_focus=True):
         async with self._refresh_lock:
             try:
                 supported = self.supported()
-            except Exception as e:
-                self._set_status(f"Terminal support check failed: {e}")
+            except Exception:
                 return
 
             if not supported:
-                try:
-                    self._set_status(self._support_message())
-                except Exception:
-                    self._set_status("Terminal not supported")
                 return
 
             try:
                 windows = tmux_manager.list_inner_windows()
-            except Exception as e:
-                self._set_status(f"Failed to query tmux windows: {e}")
+            except Exception:
                 return
             active_window_id = next((w.window_id for w in windows if w.active), None)
             if self._expanded_window_id and self._expanded_window_id != active_window_id:
@@ -419,10 +397,8 @@ class TerminalPanel(Container, can_focus=True):
 
             try:
                 await self._render_terminals(windows, titles, context_info_by_context_id)
-            except Exception as e:
-                self._set_status(f"Failed to render terminal list: {e}")
+            except Exception:
                 return
-            self._set_status(f"{len(windows)} terminals")
 
     def _fetch_claude_session_titles(self, session_ids: list[str]) -> dict[str, str]:
         if not session_ids:
@@ -487,12 +463,6 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             return ([], 0, 0)
 
-    def _set_status(self, text: str) -> None:
-        try:
-            self.query_one("#status", Static).update(text)
-        except Exception:
-            pass
-
     async def _render_terminals(
         self,
         windows: list[tmux_manager.InnerWindow],
@@ -504,7 +474,7 @@ class TerminalPanel(Container, can_focus=True):
 
         if not windows:
             await container.mount(
-                Static("No terminals yet. Click 'New cc' / 'New codex' to open the right pane.")
+                Static("No terminals yet. Click 'Create' to open a new agent terminal.")
             )
             return
 
@@ -539,9 +509,7 @@ class TerminalPanel(Container, can_focus=True):
             if w.active and can_toggle_ctx:
                 await row.mount(
                     Button(
-                        # Avoid Rich crash when Textual measures with width=0 (can happen during
-                        # initial layout / tab switching).
-                        "⮟" if expanded else "⮞",
+                        "▼" if expanded else "▶",
                         id=f"toggle-{safe}",
                         name=w.window_id,
                         variant="default",
@@ -609,9 +577,8 @@ class TerminalPanel(Container, can_focus=True):
         details.append(header)
         details.append("\n")
 
-        # Include window_name to distinguish terminals with same session_id
-        window_name = w.window_name or ""
-        detail_line = f"[{window_name}]" if window_name else "claude"
+        # Build detail line with Claude label
+        detail_line = "[Claude]"
         if w.session_id:
             detail_line = f"{detail_line} #{self._short_id(w.session_id)}"
         if w.active:
@@ -641,180 +608,149 @@ class TerminalPanel(Container, can_focus=True):
             return f"w-{safe}"
         return safe
 
-    async def _select_workspace(self, prompt: str = "Select workspace") -> str | None:
-        """Open macOS folder picker and return selected path, or None if cancelled."""
-        try:
-            default_path = os.getcwd()
-        except Exception:
-            # Can happen if the original working directory was deleted/moved.
-            default_path = str(Path.home())
-        # Use osascript to invoke macOS native folder picker
-        default_path_escaped = default_path.replace('"', '\\"')
-        prompt_escaped = prompt.replace('"', '\\"')
-        script = f"""
-            set defaultFolder to POSIX file "{default_path_escaped}" as alias
-            try
-                set selectedFolder to choose folder with prompt "{prompt_escaped}" default location defaultFolder
-                return POSIX path of selectedFolder
-            on error
-                return ""
-            end try
-        """
-        try:
-            proc = await asyncio.get_event_loop().run_in_executor(
-                None,
-                lambda: subprocess.run(
-                    ["osascript", "-e", script],
-                    capture_output=True,
-                    text=True,
-                    timeout=120,
-                ),
-            )
-            result = (proc.stdout or "").strip()
-            if result and os.path.isdir(result):
-                return result
-            return None
-        except Exception:
-            return None
-
     @staticmethod
     def _command_in_directory(command: str, directory: str) -> str:
         """Wrap a command to run in a specific directory."""
         return f"cd {shlex.quote(directory)} && {command}"
 
-    async def on_button_pressed(self, event: Button.Pressed) -> None:
-        button_id = event.button.id or ""
-
-        if button_id == "refresh":
-            await self.refresh_data()
-            return
-
-        if not self.supported():
-            self.app.notify(
-                self._support_message(),
-                title="Terminal",
-                severity="warning",
-            )
+    def _on_create_agent_result(self, result: tuple[str, str] | None) -> None:
+        """Handle the result from CreateAgentScreen modal."""
+        if result is None:
             return
 
-        if button_id == "new-cc":
-            workspace = await self._select_workspace("Select workspace for Claude")
-            if not workspace:
-                return
-
-            terminal_id = tmux_manager.new_terminal_id()
-            context_id = tmux_manager.new_context_id("cc")
-            env = {
-                tmux_manager.ENV_TERMINAL_ID: terminal_id,
-                tmux_manager.ENV_TERMINAL_PROVIDER: "claude",
-                tmux_manager.ENV_INNER_SOCKET: tmux_manager.INNER_SOCKET,
-                tmux_manager.ENV_INNER_SESSION: tmux_manager.INNER_SESSION,
-                tmux_manager.ENV_CONTEXT_ID: context_id,
-            }
-
-            try:
-                from pathlib import Path
-
-                from ...claude_hooks.stop_hook_installer import (
-                    ensure_stop_hook_installed,
-                    get_settings_path as get_stop_settings_path,
-                    install_stop_hook,
-                )
-                from ...claude_hooks.user_prompt_submit_hook_installer import (
-                    ensure_user_prompt_submit_hook_installed,
-                    get_settings_path as get_submit_settings_path,
-                    install_user_prompt_submit_hook,
-                )
-                from ...claude_hooks.permission_request_hook_installer import (
-                    ensure_permission_request_hook_installed,
-                    get_settings_path as get_permission_settings_path,
-                    install_permission_request_hook,
-                )
-
-                ok_global_stop = ensure_stop_hook_installed(quiet=True)
-                ok_global_submit = ensure_user_prompt_submit_hook_installed(quiet=True)
-                ok_global_permission = ensure_permission_request_hook_installed(quiet=True)
-
-                project_root = Path(workspace)
-                ok_project_stop = install_stop_hook(
-                    get_stop_settings_path(project_root), quiet=True
-                )
-                ok_project_submit = install_user_prompt_submit_hook(
-                    get_submit_settings_path(project_root), quiet=True
-                )
-                ok_project_permission = install_permission_request_hook(
-                    get_permission_settings_path(project_root), quiet=True
-                )
+        agent_type, workspace = result
+        self.run_worker(
+            self._create_agent(agent_type, workspace),
+            group="terminal-panel-create",
+            exclusive=True,
+        )
 
-                all_hooks_ok = (
-                    ok_global_stop
-                    and ok_global_submit
-                    and ok_global_permission
-                    and ok_project_stop
-                    and ok_project_submit
-                    and ok_project_permission
-                )
-                if not all_hooks_ok:
-                    self.app.notify(
-                        "Claude hooks not fully installed; session id/title may not update",
-                        title="Terminal",
-                        severity="warning",
-                    )
-            except Exception:
-                pass
+    async def _create_agent(self, agent_type: str, workspace: str) -> None:
+        """Create a new agent terminal based on the selected type and workspace."""
+        if agent_type == "claude":
+            await self._create_claude_terminal(workspace)
+        elif agent_type == "codex":
+            await self._create_codex_terminal(workspace)
+        elif agent_type == "opencode":
+            await self._create_opencode_terminal(workspace)
+        elif agent_type == "zsh":
+            await self._create_zsh_terminal(workspace)
+        await self.refresh_data()
+
+    async def _create_claude_terminal(self, workspace: str) -> None:
+        """Create a new Claude terminal."""
+        terminal_id = tmux_manager.new_terminal_id()
+        context_id = tmux_manager.new_context_id("cc")
+        env = {
+            tmux_manager.ENV_TERMINAL_ID: terminal_id,
+            tmux_manager.ENV_TERMINAL_PROVIDER: "claude",
+            tmux_manager.ENV_INNER_SOCKET: tmux_manager.INNER_SOCKET,
+            tmux_manager.ENV_INNER_SESSION: tmux_manager.INNER_SESSION,
+            tmux_manager.ENV_CONTEXT_ID: context_id,
+        }
 
-            command = self._command_in_directory(
-                tmux_manager.zsh_run_and_keep_open("claude"), workspace
+        try:
+            from ...claude_hooks.stop_hook_installer import (
+                ensure_stop_hook_installed,
+                get_settings_path as get_stop_settings_path,
+                install_stop_hook,
             )
-            created = tmux_manager.create_inner_window(
-                "cc",
-                tmux_manager.shell_command_with_env(command, env),
-                terminal_id=terminal_id,
-                provider="claude",
-                context_id=context_id,
+            from ...claude_hooks.user_prompt_submit_hook_installer import (
+                ensure_user_prompt_submit_hook_installed,
+                get_settings_path as get_submit_settings_path,
+                install_user_prompt_submit_hook,
+            )
+            from ...claude_hooks.permission_request_hook_installer import (
+                ensure_permission_request_hook_installed,
+                get_settings_path as get_permission_settings_path,
+                install_permission_request_hook,
             )
-            if not created:
-                self.app.notify("Failed to open cc terminal", title="Terminal", severity="error")
-            await self.refresh_data()
-            return
 
-        if button_id == "new-codex":
-            workspace = await self._select_workspace("Select workspace for Codex")
-            if not workspace:
-                return
+            ok_global_stop = ensure_stop_hook_installed(quiet=True)
+            ok_global_submit = ensure_user_prompt_submit_hook_installed(quiet=True)
+            ok_global_permission = ensure_permission_request_hook_installed(quiet=True)
 
-            command = self._command_in_directory(
-                tmux_manager.zsh_run_and_keep_open("codex"), workspace
+            project_root = Path(workspace)
+            ok_project_stop = install_stop_hook(
+                get_stop_settings_path(project_root), quiet=True
+            )
+            ok_project_submit = install_user_prompt_submit_hook(
+                get_submit_settings_path(project_root), quiet=True
+            )
+            ok_project_permission = install_permission_request_hook(
+                get_permission_settings_path(project_root), quiet=True
             )
-            created = tmux_manager.create_inner_window("codex", command)
-            if not created:
-                self.app.notify("Failed to open codex terminal", title="Terminal", severity="error")
-            await self.refresh_data()
-            return
-
-        if button_id == "new-opencode":
-            workspace = await self._select_workspace("Select workspace for Opencode")
-            if not workspace:
-                return
 
-            command = self._command_in_directory(
-                tmux_manager.zsh_run_and_keep_open("opencode"), workspace
+            all_hooks_ok = (
+                ok_global_stop
+                and ok_global_submit
+                and ok_global_permission
+                and ok_project_stop
+                and ok_project_submit
+                and ok_project_permission
             )
-            created = tmux_manager.create_inner_window("opencode", command)
-            if not created:
+            if not all_hooks_ok:
                 self.app.notify(
-                    "Failed to open opencode terminal",
+                    "Claude hooks not fully installed; session id/title may not update",
                     title="Terminal",
-                    severity="error",
+                    severity="warning",
                 )
-            await self.refresh_data()
+        except Exception:
+            pass
+
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open("claude"), workspace
+        )
+        created = tmux_manager.create_inner_window(
+            "cc",
+            tmux_manager.shell_command_with_env(command, env),
+            terminal_id=terminal_id,
+            provider="claude",
+            context_id=context_id,
+        )
+        if not created:
+            self.app.notify("Failed to open Claude terminal", title="Terminal", severity="error")
+
+    async def _create_codex_terminal(self, workspace: str) -> None:
+        """Create a new Codex terminal."""
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open("codex"), workspace
+        )
+        created = tmux_manager.create_inner_window("codex", command)
+        if not created:
+            self.app.notify("Failed to open Codex terminal", title="Terminal", severity="error")
+
+    async def _create_opencode_terminal(self, workspace: str) -> None:
+        """Create a new Opencode terminal."""
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open("opencode"), workspace
+        )
+        created = tmux_manager.create_inner_window("opencode", command)
+        if not created:
+            self.app.notify("Failed to open Opencode terminal", title="Terminal", severity="error")
+
+    async def _create_zsh_terminal(self, workspace: str) -> None:
+        """Create a new zsh terminal."""
+        command = self._command_in_directory("zsh", workspace)
+        created = tmux_manager.create_inner_window("zsh", command)
+        if not created:
+            self.app.notify("Failed to open zsh terminal", title="Terminal", severity="error")
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id or ""
+
+        if not self.supported():
+            self.app.notify(
+                self._support_message(),
+                title="Terminal",
+                severity="warning",
+            )
             return
 
-        if button_id == "new-zsh":
-            created = tmux_manager.create_inner_window("zsh", "zsh")
-            if not created:
-                self.app.notify("Failed to open zsh terminal", title="Terminal", severity="error")
-            await self.refresh_data()
+        if button_id == "new-agent":
+            from ..screens import CreateAgentScreen
+
+            self.app.push_screen(CreateAgentScreen(), self._on_create_agent_result)
             return
 
         if button_id.startswith("switch-"):