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

realign/dashboard/widgets/config_panel.py

@@ -6,7 +6,9 @@ from typing import Optional
 
 from textual.app import ComposeResult
 from textual.containers import Horizontal
-from textual.widgets import Button, DataTable, Input, Static
+from textual.widgets import Button, DataTable, Input, Static, Switch
+
+from ..tmux_manager import _run_outer_tmux, OUTER_SESSION
 
 
 class ConfigPanel(Static):
@@ -51,6 +53,27 @@ class ConfigPanel(Static):
     ConfigPanel .button-row Button {
         margin-right: 1;
     }
+
+    ConfigPanel .tmux-settings {
+        height: auto;
+        margin-top: 1;
+        padding: 1;
+        border: solid $secondary;
+    }
+
+    ConfigPanel .tmux-settings .setting-row {
+        height: 3;
+        align: left middle;
+    }
+
+    ConfigPanel .tmux-settings .setting-label {
+        width: auto;
+        margin-right: 1;
+    }
+
+    ConfigPanel .tmux-settings Switch {
+        width: auto;
+    }
     """
 
     def __init__(self) -> None:
@@ -58,6 +81,8 @@ class ConfigPanel(Static):
         self._config_path: Optional[Path] = None
         self._config_data: dict = {}
         self._selected_key: Optional[str] = None
+        self._border_resize_enabled: bool = True  # Track tmux border resize state
+        self._syncing_switch: bool = False  # Flag to prevent recursive switch updates
 
     def compose(self) -> ComposeResult:
         """Compose the config panel layout."""
@@ -71,6 +96,13 @@ class ConfigPanel(Static):
             yield Button("Save", id="save-btn", variant="primary")
             yield Button("Reload", id="reload-btn", variant="default")
 
+        # Tmux settings section
+        with Static(classes="tmux-settings"):
+            yield Static("[bold]Tmux Settings[/bold]", classes="section-title")
+            with Horizontal(classes="setting-row"):
+                yield Static("Allow border resize:", classes="setting-label")
+                yield Switch(value=True, id="border-resize-switch")
+
     def on_mount(self) -> None:
         """Set up the panel on mount."""
         table = self.query_one("#config-table", DataTable)
@@ -80,6 +112,9 @@ class ConfigPanel(Static):
         # Load initial data
         self.refresh_data()
 
+        # Query and set the actual tmux border resize state
+        self._sync_border_resize_switch()
+
     def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None:
         """Handle row selection in the config table."""
         table = self.query_one("#config-table", DataTable)
@@ -114,6 +149,55 @@ class ConfigPanel(Static):
             self.refresh_data()
             self.app.notify("Configuration reloaded", title="Config")
 
+    def on_switch_changed(self, event: Switch.Changed) -> None:
+        """Handle switch toggle events."""
+        if self._syncing_switch:
+            return  # Ignore events during sync
+        if event.switch.id == "border-resize-switch":
+            self._toggle_border_resize(event.value)
+
+    def _sync_border_resize_switch(self) -> None:
+        """Query tmux state and sync the switch to match."""
+        try:
+            # Check if MouseDrag1Border is bound by listing keys
+            result = _run_outer_tmux(["list-keys", "-T", "root"], capture=True)
+            output = result.stdout or ""
+
+            # If MouseDrag1Border is in the output, resize is enabled
+            is_enabled = "MouseDrag1Border" in output
+            self._border_resize_enabled = is_enabled
+
+            # Update switch without triggering the toggle action
+            self._syncing_switch = True
+            try:
+                switch = self.query_one("#border-resize-switch", Switch)
+                switch.value = is_enabled
+            finally:
+                self._syncing_switch = False
+        except Exception:
+            # If we can't query, assume enabled (default tmux behavior)
+            pass
+
+    def _toggle_border_resize(self, enabled: bool) -> None:
+        """Enable or disable tmux border resize functionality."""
+        try:
+            if enabled:
+                # Re-enable border resize by binding MouseDrag1Border to default resize behavior
+                _run_outer_tmux([
+                    "bind", "-n", "MouseDrag1Border", "resize-pane", "-M"
+                ])
+                self._border_resize_enabled = True
+                self.app.notify("Border resize enabled", title="Tmux")
+            else:
+                # Disable border resize by unbinding MouseDrag1Border
+                _run_outer_tmux([
+                    "unbind", "-n", "MouseDrag1Border"
+                ])
+                self._border_resize_enabled = False
+                self.app.notify("Border resize disabled", title="Tmux")
+        except Exception as e:
+            self.app.notify(f"Error toggling border resize: {e}", title="Tmux", severity="error")
+
     def _save_config(self) -> None:
         """Save the edited configuration."""
         if not self._selected_key:

realign/dashboard/widgets/events_table.py

@@ -563,7 +563,9 @@ class EventsTable(Container, can_focus=True):
         selected_event_id = None
         try:
             if table.row_count > 0:
-                selected_event_id = str(table.coordinate_to_cell_key(table.cursor_coordinate)[0].value)
+                selected_event_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
         except Exception:
             selected_event_id = None
         if self.wrap_mode != self._last_wrap_mode:

realign/dashboard/widgets/header.py

@@ -23,6 +23,7 @@ class AlineHeader(Static):
         """Get the Aline version."""
         try:
             from importlib.metadata import version
+
             return version("aline-ai")
         except Exception:
             return "0.4.1"

realign/dashboard/widgets/search_panel.py

@@ -115,7 +115,9 @@ class SearchPanel(Static):
             session_id = result.get("session_id") or ""
             turn_id = result.get("turn_id") or ""
             if session_id:
-                self.app.push_screen(SessionDetailScreen(session_id, initial_turn_id=turn_id or None))
+                self.app.push_screen(
+                    SessionDetailScreen(session_id, initial_turn_id=turn_id or None)
+                )
             return
 
     def on_input_submitted(self, event: Input.Submitted) -> None:
@@ -156,30 +158,32 @@ class SearchPanel(Static):
 
             # Search based on type
             if self._search_type in ("all", "event"):
-                events = db.search_events(
-                    self._query, limit=20, use_regex=True, ignore_case=True
-                )
+                events = db.search_events(self._query, limit=20, use_regex=True, ignore_case=True)
                 for event in events:
-                    self._results.append({
-                        "type": "Event",
-                        "id": self._shorten_id(event.id),
-                        "full_id": event.id,
-                        "title": (event.title or "(no title)")[:60],
-                        "context": event.event_type or "-",
-                    })
+                    self._results.append(
+                        {
+                            "type": "Event",
+                            "id": self._shorten_id(event.id),
+                            "full_id": event.id,
+                            "title": (event.title or "(no title)")[:60],
+                            "context": event.event_type or "-",
+                        }
+                    )
 
             if self._search_type in ("all", "session"):
                 sessions = db.search_sessions(
                     self._query, limit=20, use_regex=True, ignore_case=True
                 )
                 for session in sessions:
-                    self._results.append({
-                        "type": "Session",
-                        "id": self._shorten_id(session.id),
-                        "full_id": session.id,
-                        "title": (session.session_title or "(no title)")[:60],
-                        "context": session.session_type or "-",
-                    })
+                    self._results.append(
+                        {
+                            "type": "Session",
+                            "id": self._shorten_id(session.id),
+                            "full_id": session.id,
+                            "title": (session.session_title or "(no title)")[:60],
+                            "context": session.session_type or "-",
+                        }
+                    )
 
             if self._search_type in ("all", "turn"):
                 turns = db.search_conversations(
@@ -188,14 +192,18 @@ class SearchPanel(Static):
                 for turn in turns:
                     session_id = turn.get("session_id", "")
                     turn_id = turn.get("turn_id", "")
-                    self._results.append({
-                        "type": "Turn",
-                        "id": self._shorten_id(turn_id),
-                        "turn_id": turn_id,
-                        "session_id": session_id,
-                        "title": (turn.get("title") or turn.get("summary") or "(no title)")[:60],
-                        "context": f"{self._shorten_id(session_id)} • Turn #{turn.get('turn_number', '-')}",
-                    })
+                    self._results.append(
+                        {
+                            "type": "Turn",
+                            "id": self._shorten_id(turn_id),
+                            "turn_id": turn_id,
+                            "session_id": session_id,
+                            "title": (turn.get("title") or turn.get("summary") or "(no title)")[
+                                :60
+                            ],
+                            "context": f"{self._shorten_id(session_id)} • Turn #{turn.get('turn_number', '-')}",
+                        }
+                    )
 
             self._update_display()
 
@@ -232,7 +240,9 @@ class SearchPanel(Static):
 
             summary_text = f"Found {len(self._results)} results for '{self._query}'"
             if self._search_type == "all":
-                summary_text += f" (Events: {event_count}, Sessions: {session_count}, Turns: {turn_count})"
+                summary_text += (
+                    f" (Events: {event_count}, Sessions: {session_count}, Turns: {turn_count})"
+                )
 
             summary.update(f"[dim]{summary_text}[/dim]")
         else:

realign/dashboard/widgets/sessions_table.py

@@ -461,14 +461,16 @@ class SessionsTable(Container, can_focus=True):
                 total_sessions = int(row[0]) if row else 0
 
                 # Get stats
-                stats_row = conn.execute("""
+                stats_row = conn.execute(
+                    """
                     SELECT
                         COUNT(*) AS total,
                         COUNT(CASE WHEN session_type = 'claude' THEN 1 END) AS claude,
                         COUNT(CASE WHEN session_type = 'codex' THEN 1 END) AS codex,
                         COUNT(CASE WHEN session_type = 'gemini' THEN 1 END) AS gemini
                     FROM sessions
-                """).fetchone()
+                """
+                ).fetchone()
 
                 stats = {
                     "total": stats_row[0] if stats_row else 0,
@@ -479,7 +481,8 @@ class SessionsTable(Container, can_focus=True):
 
                 # Get paginated sessions
                 offset = (int(page) - 1) * int(rows_per_page)
-                rows = conn.execute("""
+                rows = conn.execute(
+                    """
                     SELECT
                         s.id,
                         s.session_type,
@@ -490,7 +493,9 @@ class SessionsTable(Container, can_focus=True):
                     FROM sessions s
                     ORDER BY s.last_activity_at DESC
                     LIMIT ? OFFSET ?
-                """, (int(rows_per_page), int(offset))).fetchall()
+                """,
+                    (int(rows_per_page), int(offset)),
+                ).fetchall()
 
                 for i, row in enumerate(rows):
                     session_id = row[0]
@@ -517,16 +522,18 @@ class SessionsTable(Container, can_focus=True):
                         except Exception:
                             activity_str = last_activity
 
-                    sessions.append({
-                        "index": offset + i + 1,
-                        "id": session_id,
-                        "short_id": self._shorten_session_id(session_id),
-                        "source": source,
-                        "project": project,
-                        "turns": turn_count,
-                        "title": title,
-                        "last_activity": activity_str,
-                    })
+                    sessions.append(
+                        {
+                            "index": offset + i + 1,
+                            "id": session_id,
+                            "short_id": self._shorten_session_id(session_id),
+                            "source": source,
+                            "project": project,
+                            "turns": turn_count,
+                            "title": title,
+                            "last_activity": activity_str,
+                        }
+                    )
         except Exception:
             total_sessions = 0
             stats = {}
@@ -553,7 +560,9 @@ class SessionsTable(Container, can_focus=True):
         selected_session_id: Optional[str] = None
         try:
             if table.row_count > 0:
-                selected_session_id = str(table.coordinate_to_cell_key(table.cursor_coordinate)[0].value)
+                selected_session_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
         except Exception:
             selected_session_id = None
         if self.wrap_mode != self._last_wrap_mode:

realign/dashboard/widgets/terminal_panel.py

@@ -13,16 +13,126 @@ import re
 import shlex
 import subprocess
 from pathlib import Path
+from typing import Callable
 
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical, VerticalScroll
+from textual.message import Message
 from textual.widgets import Button, Static
 from rich.text import Text
 
 from .. import tmux_manager
 
 
+# Signal directory for permission request notifications
+PERMISSION_SIGNAL_DIR = Path.home() / ".aline" / ".signals" / "permission_request"
+
+
+class _SignalFileWatcher:
+    """Watches for new signal files in the permission_request directory.
+
+    Uses OS-native file watching via asyncio when available,
+    otherwise falls back to checking directory mtime.
+    """
+
+    def __init__(self, callback: Callable[[], None]) -> None:
+        self._callback = callback
+        self._running = False
+        self._task: asyncio.Task | None = None
+        self._last_mtime: float = 0
+        self._seen_files: set[str] = set()
+
+    def start(self) -> None:
+        if self._running:
+            return
+        self._running = True
+        # Initialize seen files
+        self._scan_existing_files()
+        self._task = asyncio.create_task(self._watch_loop())
+
+    def stop(self) -> None:
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            self._task = None
+
+    def _scan_existing_files(self) -> None:
+        """Record existing signal files so we only react to new ones."""
+        try:
+            if PERMISSION_SIGNAL_DIR.exists():
+                self._seen_files = {
+                    f.name for f in PERMISSION_SIGNAL_DIR.iterdir() if f.suffix == ".signal"
+                }
+        except Exception:
+            self._seen_files = set()
+
+    async def _watch_loop(self) -> None:
+        """Watch for new signal files using directory mtime checks."""
+        try:
+            while self._running:
+                # Wait a bit before checking (reduces CPU usage)
+                await asyncio.sleep(0.5)
+
+                if not self._running:
+                    break
+
+                try:
+                    if not PERMISSION_SIGNAL_DIR.exists():
+                        continue
+
+                    # Check if directory was modified
+                    current_mtime = PERMISSION_SIGNAL_DIR.stat().st_mtime
+                    if current_mtime <= self._last_mtime:
+                        continue
+                    self._last_mtime = current_mtime
+
+                    # Check for new signal files
+                    current_files = {
+                        f.name for f in PERMISSION_SIGNAL_DIR.iterdir() if f.suffix == ".signal"
+                    }
+                    new_files = current_files - self._seen_files
+
+                    if new_files:
+                        self._seen_files = current_files
+                        # New signal file detected - trigger callback
+                        self._callback()
+                        # Clean up old signal files (keep last 10)
+                        self._cleanup_old_signals()
+
+                except Exception:
+                    pass  # Ignore errors, keep watching
+
+        except asyncio.CancelledError:
+            pass
+
+    def _cleanup_old_signals(self) -> None:
+        """Remove old signal files to prevent directory from growing."""
+        try:
+            if not PERMISSION_SIGNAL_DIR.exists():
+                return
+            files = sorted(
+                PERMISSION_SIGNAL_DIR.glob("*.signal"),
+                key=lambda f: f.stat().st_mtime,
+                reverse=True,
+            )
+            # Keep only the 10 most recent
+            for f in files[10:]:
+                try:
+                    f.unlink()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+
 class TerminalPanel(Container, can_focus=True):
+    """Terminal controls panel with permission request notifications."""
+
+    class PermissionRequestDetected(Message):
+        """Posted when a new permission request signal file is detected."""
+
+        pass
+
     DEFAULT_CSS = """
     TerminalPanel {
         height: 100%;
@@ -179,18 +289,37 @@ class TerminalPanel(Container, can_focus=True):
         super().__init__()
         self._refresh_lock = asyncio.Lock()
         self._expanded_window_id: str | None = None
+        self._signal_watcher: _SignalFileWatcher | None = None
 
     def compose(self) -> ComposeResult:
         controls_enabled = self.supported()
         with Horizontal(classes="summary"):
-            yield Button("＋ Claude", id="new-cc", variant="primary", disabled=not controls_enabled)
-            yield Button("＋ Codex", id="new-codex", variant="primary", disabled=not controls_enabled)
+            yield Button(
+                "＋ Claude",
+                id="new-cc",
+                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.")
+                yield Static(
+                    "No terminals yet. Click 'New cc' / 'New codex' to open the right pane."
+                )
             else:
                 yield Static(self._support_message())
 
@@ -205,6 +334,40 @@ class TerminalPanel(Container, can_focus=True):
                 exclusive=True,
             )
         )
+        # Start watching for permission request signals
+        self._start_signal_watcher()
+
+    def on_hide(self) -> None:
+        # Stop watching when panel is hidden
+        self._stop_signal_watcher()
+
+    def _start_signal_watcher(self) -> None:
+        """Start watching for permission request signal files."""
+        if self._signal_watcher is not None:
+            return
+        self._signal_watcher = _SignalFileWatcher(self._on_permission_signal)
+        self._signal_watcher.start()
+
+    def _stop_signal_watcher(self) -> None:
+        """Stop watching for permission request signal files."""
+        if self._signal_watcher is not None:
+            self._signal_watcher.stop()
+            self._signal_watcher = None
+
+    def _on_permission_signal(self) -> None:
+        """Called when a new permission request signal is detected."""
+        # Post message to trigger refresh on the main thread
+        self.post_message(self.PermissionRequestDetected())
+
+    def on_terminal_panel_permission_request_detected(
+        self, event: PermissionRequestDetected
+    ) -> None:
+        """Handle permission request detection - refresh the terminal list."""
+        self.run_worker(
+            self.refresh_data(),
+            group="terminal-panel-refresh",
+            exclusive=True,
+        )
 
     async def refresh_data(self) -> None:
         async with self._refresh_lock:
@@ -239,10 +402,16 @@ class TerminalPanel(Container, can_focus=True):
             for w in windows:
                 if not self._is_claude_window(w) or not w.context_id:
                     continue
-                session_ids, session_count, event_count = self._get_loaded_context_info(w.context_id)
+                session_ids, session_count, event_count = self._get_loaded_context_info(
+                    w.context_id
+                )
                 if not session_ids and session_count == 0 and event_count == 0:
                     continue
-                context_info_by_context_id[w.context_id] = (session_ids, session_count, event_count)
+                context_info_by_context_id[w.context_id] = (
+                    session_ids,
+                    session_count,
+                    event_count,
+                )
                 all_context_session_ids.update(session_ids)
 
             if all_context_session_ids:
@@ -390,12 +559,7 @@ class TerminalPanel(Container, can_focus=True):
                 )
             )
 
-            if (
-                w.active
-                and self._is_claude_window(w)
-                and w.context_id
-                and expanded
-            ):
+            if w.active and self._is_claude_window(w) and w.context_id and expanded:
                 ctx = VerticalScroll(id=f"ctx-{safe}", classes="context-sessions")
                 await container.mount(ctx)
                 if loaded_ids:
@@ -454,7 +618,9 @@ class TerminalPanel(Container, can_focus=True):
             loaded_count = raw_sessions + raw_events
             detail_line = f"{detail_line} | loaded context: {loaded_count}"
         else:
-            detail_line = f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+            detail_line = (
+                f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+            )
         details.append(detail_line, style="dim not bold")
         return details
 
@@ -485,7 +651,7 @@ class TerminalPanel(Container, can_focus=True):
         # Use osascript to invoke macOS native folder picker
         default_path_escaped = default_path.replace('"', '\\"')
         prompt_escaped = prompt.replace('"', '\\"')
-        script = f'''
+        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
@@ -493,7 +659,7 @@ class TerminalPanel(Container, can_focus=True):
             on error
                 return ""
             end try
-        '''
+        """
         try:
             proc = await asyncio.get_event_loop().run_in_executor(
                 None,
@@ -570,7 +736,9 @@ class TerminalPanel(Container, can_focus=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_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
                 )
@@ -579,8 +747,12 @@ class TerminalPanel(Container, can_focus=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
+                    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(
@@ -620,6 +792,24 @@ class TerminalPanel(Container, can_focus=True):
             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
+            )
+            created = tmux_manager.create_inner_window("opencode", command)
+            if not created:
+                self.app.notify(
+                    "Failed to open opencode terminal",
+                    title="Terminal",
+                    severity="error",
+                )
+            await self.refresh_data()
+            return
+
         if button_id == "new-zsh":
             created = tmux_manager.create_inner_window("zsh", "zsh")
             if not created:

realign/dashboard/widgets/watcher_panel.py

@@ -389,7 +389,9 @@ class WatcherPanel(Container, can_focus=True):
         except Exception:
             return []
 
-    def _collect_recent_sessions_page(self, *, page: int, rows_per_page: int) -> tuple[list[dict], int]:
+    def _collect_recent_sessions_page(
+        self, *, page: int, rows_per_page: int
+    ) -> tuple[list[dict], int]:
         """Collect one page of recent sessions from the database."""
         try:
             from ...db import get_database
@@ -477,7 +479,9 @@ class WatcherPanel(Container, can_focus=True):
                 if exists:
                     paths_lines.append(f"  [green]●[/green] {name}: {path}")
                 else:
-                    paths_lines.append(f"  [yellow]○[/yellow] {name}: {path} [dim](not found)[/dim]")
+                    paths_lines.append(
+                        f"  [yellow]○[/yellow] {name}: {path} [dim](not found)[/dim]"
+                    )
             else:
                 paths_lines.append(f"  [dim]○ {name}: {path} (disabled)[/dim]")
         paths_widget.update("\n".join(paths_lines))