aline-ai 0.7.3__py3-none-any.whl → 0.7.4__py3-none-any.whl

realign/dashboard/widgets/config_panel.py

@@ -38,15 +38,6 @@ class ConfigPanel(Static):
         margin-bottom: 1;
     }
 
-    ConfigPanel .button-row {
-        height: 3;
-        margin-top: 1;
-    }
-
-    ConfigPanel .button-row Button {
-        margin-right: 1;
-    }
-
     ConfigPanel .account-section {
         height: 3;
         align: left middle;
@@ -62,81 +53,36 @@ class ConfigPanel(Static):
         margin-right: 1;
     }
 
-    ConfigPanel .tmux-settings {
+    ConfigPanel .settings-section {
         height: auto;
         margin-top: 2;
     }
 
-    ConfigPanel .tmux-settings .setting-row {
+    ConfigPanel .settings-section .setting-row {
         height: auto;
     }
 
-    ConfigPanel .tmux-settings .setting-label {
-        width: auto;
+    ConfigPanel .settings-section .setting-label {
+        width: 16;
     }
 
-    ConfigPanel .tmux-settings RadioSet {
+    ConfigPanel .settings-section RadioSet {
         width: auto;
         height: auto;
         layout: horizontal;
     }
 
-    ConfigPanel .tmux-settings RadioButton {
+    ConfigPanel .settings-section RadioButton {
         width: auto;
         margin-right: 2;
     }
 
-    ConfigPanel .tools-section {
-        height: auto;
-        margin-top: 2;
-    }
-
-    ConfigPanel .terminal-settings {
-        height: auto;
-        margin-top: 2;
-    }
-
-    ConfigPanel .terminal-settings .setting-row {
-        height: auto;
-    }
-
-    ConfigPanel .terminal-settings .setting-label {
-        width: auto;
-    }
-
-    ConfigPanel .terminal-settings RadioSet {
-        width: auto;
-        height: auto;
-        layout: horizontal;
-    }
-
-    ConfigPanel .terminal-settings RadioButton {
-        width: auto;
-        margin-right: 2;
-    }
-
-    ConfigPanel .appearance-settings {
-        height: auto;
-        margin-top: 2;
-    }
-
-    ConfigPanel .appearance-settings .setting-row {
-        height: auto;
-    }
-
-    ConfigPanel .appearance-settings .setting-label {
-        width: auto;
-    }
-
-    ConfigPanel .appearance-settings RadioSet {
-        width: auto;
-        height: auto;
-        layout: horizontal;
+    ConfigPanel .settings-section .button-row {
+        height: 3;
     }
 
-    ConfigPanel .appearance-settings RadioButton {
-        width: auto;
-        margin-right: 2;
+    ConfigPanel .settings-section .button-row Button {
+        margin-right: 1;
     }
     """
 
@@ -146,7 +92,6 @@ class ConfigPanel(Static):
         self._syncing_radio: bool = False  # Flag to prevent recursive radio updates
         self._login_in_progress: bool = False  # Track login state
         self._refresh_timer = None  # Timer for auto-refresh
-        self._auto_close_stale_enabled: bool = False  # Track auto-close setting
 
     def compose(self) -> ComposeResult:
         """Compose the config panel layout."""
@@ -157,7 +102,7 @@ class ConfigPanel(Static):
             yield Button("Login", id="auth-btn", variant="primary")
 
         # Appearance settings section
-        with Static(classes="appearance-settings"):
+        with Static(classes="settings-section"):
             yield Static("[bold]Appearance[/bold]", classes="section-title")
             with Horizontal(classes="setting-row"):
                 yield Static("Theme:", classes="setting-label")
@@ -166,7 +111,7 @@ class ConfigPanel(Static):
                     yield RadioButton("Light", id="theme-light")
 
         # Tmux settings section
-        with Static(classes="tmux-settings"):
+        with Static(classes="settings-section"):
             yield Static("[bold]Tmux Settings[/bold]", classes="section-title")
             with Horizontal(classes="setting-row"):
                 yield Static("Border resize:", classes="setting-label")
@@ -174,17 +119,8 @@ class ConfigPanel(Static):
                     yield RadioButton("Enabled", id="border-resize-enabled", value=True)
                     yield RadioButton("Disabled", id="border-resize-disabled")
 
-        # Terminal settings section
-        with Static(classes="terminal-settings"):
-            yield Static("[bold]Terminal Settings[/bold]", classes="section-title")
-            with Horizontal(classes="setting-row"):
-                yield Static("Auto-close stale terminals (24h):", classes="setting-label")
-                with RadioSet(id="auto-close-stale-radio"):
-                    yield RadioButton("Enabled", id="auto-close-stale-enabled")
-                    yield RadioButton("Disabled", id="auto-close-stale-disabled", value=True)
-
         # Tools section
-        with Static(classes="tools-section"):
+        with Static(classes="settings-section"):
             yield Static("[bold]Tools[/bold]", classes="section-title")
             with Horizontal(classes="button-row"):
                 yield Button("Aline Doctor", id="doctor-btn", variant="default")
@@ -200,11 +136,25 @@ class ConfigPanel(Static):
         # Query and set the actual tmux border resize state
         self._sync_border_resize_radio()
 
-        # Sync auto-close stale terminals setting from config
-        self._sync_auto_close_stale_radio()
+    def on_show(self) -> None:
+        """Start periodic refresh when visible."""
+        if self._refresh_timer is None:
+            self._refresh_timer = self.set_interval(5.0, self._update_account_status)
+        else:
+            try:
+                self._refresh_timer.resume()
+            except Exception:
+                pass
+        self._update_account_status()
 
-        # Start timer to periodically refresh account status (every 5 seconds)
-        self._refresh_timer = self.set_interval(5.0, self._update_account_status)
+    def on_hide(self) -> None:
+        """Pause periodic refresh when hidden."""
+        if self._refresh_timer is None:
+            return
+        try:
+            self._refresh_timer.pause()
+        except Exception:
+            pass
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
         """Handle button clicks."""
@@ -228,9 +178,6 @@ class ConfigPanel(Static):
             # Check which radio button is selected
             enabled = event.pressed.id == "border-resize-enabled"
             self._toggle_border_resize(enabled)
-        elif event.radio_set.id == "auto-close-stale-radio":
-            enabled = event.pressed.id == "auto-close-stale-enabled"
-            self._toggle_auto_close_stale(enabled)
 
     def _update_account_status(self) -> None:
         """Update the account status display."""
@@ -379,7 +326,7 @@ class ConfigPanel(Static):
         """Query tmux state and sync the radio buttons to match."""
         try:
             # Check if MouseDrag1Border is bound by listing keys
-            result = _run_outer_tmux(["list-keys", "-T", "root"], capture=True)
+            result = _run_outer_tmux(["list-keys", "-T", "root"], capture=True, timeout_s=0.5)
             output = result.stdout or ""
 
             # If MouseDrag1Border is in the output, resize is enabled
@@ -407,53 +354,19 @@ class ConfigPanel(Static):
                 # Re-enable border resize by binding MouseDrag1Border to default resize behavior
                 _run_outer_tmux([
                     "bind", "-n", "MouseDrag1Border", "resize-pane", "-M"
-                ])
+                ], timeout_s=0.5)
                 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"
-                ])
+                ], timeout_s=0.5)
                 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 _sync_auto_close_stale_radio(self) -> None:
-        """Sync radio buttons with config file setting."""
-        try:
-            config = ReAlignConfig.load()
-            is_enabled = config.auto_close_stale_terminals
-            self._auto_close_stale_enabled = is_enabled
-
-            # Update radio buttons without triggering the toggle action
-            self._syncing_radio = True
-            try:
-                if is_enabled:
-                    radio = self.query_one("#auto-close-stale-enabled", RadioButton)
-                else:
-                    radio = self.query_one("#auto-close-stale-disabled", RadioButton)
-                radio.value = True
-            finally:
-                self._syncing_radio = False
-        except Exception:
-            pass
-
-    def _toggle_auto_close_stale(self, enabled: bool) -> None:
-        """Enable or disable auto-close stale terminals setting."""
-        try:
-            config = ReAlignConfig.load()
-            config.auto_close_stale_terminals = enabled
-            config.save()
-            self._auto_close_stale_enabled = enabled
-            if enabled:
-                self.app.notify("Auto-close stale terminals enabled", title="Terminal")
-            else:
-                self.app.notify("Auto-close stale terminals disabled", title="Terminal")
-        except Exception as e:
-            self.app.notify(f"Error saving setting: {e}", title="Config", severity="error")
-
     def _handle_doctor(self) -> None:
         """Run aline doctor directly in background thread."""
         self.app.notify("Running Aline Doctor...", title="Doctor")

realign/dashboard/widgets/header.py

@@ -40,5 +40,5 @@ class AlineHeader(Static):
         line3 = " ███████║██║     ██║██╔██╗ ██║█████╗  "
         line4 = " ██╔══██║██║     ██║██║╚██╗██║██╔══╝  "
         line5 = " ██║  ██║███████╗██║██║ ╚████║███████╗"
-        info = f"[dim]v{self._version} │ Shared Agent Context[/dim]"
+        info = f"[dim]v{self._version}[/dim]"
         return f"{line1}\n{line2}\n{line3}\n{line4}\n{line5}  {info}"

realign/db/sqlite_db.py

@@ -958,15 +958,23 @@ class SQLiteDatabase(DatabaseInterface):
                     kind=excluded.kind,
                     payload=excluded.payload,
                     priority=MAX(COALESCE(jobs.priority, 0), COALESCE(excluded.priority, 0)),
+                    attempts=CASE
+                        WHEN jobs.status='retry' THEN 0
+                        ELSE COALESCE(jobs.attempts, 0)
+                    END,
                     updated_at=datetime('now'),
                     reschedule=CASE
                         WHEN jobs.status='processing' THEN 1
                         ELSE COALESCE(jobs.reschedule, 0)
                     END,
+                    last_error=CASE
+                        WHEN jobs.status='retry' THEN NULL
+                        ELSE jobs.last_error
+                    END,
                     status=CASE
                         WHEN jobs.status='processing' THEN jobs.status
                         WHEN jobs.status='queued' THEN jobs.status
-                        WHEN jobs.status='retry' THEN jobs.status
+                        WHEN jobs.status='retry' THEN 'queued'
                         WHEN jobs.status='done' AND ? = 0 THEN jobs.status
                         ELSE 'queued'
                     END,
@@ -1074,6 +1082,56 @@ class SQLiteDatabase(DatabaseInterface):
             requeue_done=True,
         )
 
+    def enqueue_session_process_job(
+        self,
+        *,
+        session_file_path: Path,
+        session_id: str | None = None,
+        workspace_path: str | Path | None = None,
+        session_type: str | None = None,
+        source_event: str | None = None,
+        no_track: bool = False,
+        agent_id: str | None = None,
+        terminal_id: str | None = None,
+        priority: int = 15,
+    ) -> str:
+        """Enqueue a per-session processing job.
+
+        This is the preferred way to react to Stop hooks / file changes:
+        - Dedupe by session_id so repeated enqueues don't pile up.
+        - Worker will process all missing turns up to the safe boundary.
+        """
+        sid = (session_id or session_file_path.stem or "").strip()
+        if not sid:
+            raise ValueError("session_id is required for session_process job")
+        dedupe_key = f"session_process:{sid}"
+        payload: Dict[str, Any] = {
+            "session_id": sid,
+            "session_file_path": str(session_file_path),
+        }
+        if workspace_path is not None:
+            payload["workspace_path"] = str(workspace_path)
+        if session_type:
+            payload["session_type"] = str(session_type)
+        if source_event:
+            payload["source_event"] = str(source_event)
+        if no_track:
+            payload["no_track"] = True
+        if agent_id:
+            payload["agent_id"] = agent_id
+        if terminal_id:
+            payload["terminal_id"] = terminal_id
+
+        # Always requeue: session_process is an "edge triggered" event that may arrive
+        # after new turns were appended. Even if the last job is done, re-run to catch up.
+        return self.enqueue_job(
+            kind="session_process",
+            dedupe_key=dedupe_key,
+            payload=payload,
+            priority=int(priority),
+            requeue_done=True,
+        )
+
     def enqueue_agent_description_job(self, *, agent_id: str) -> str:
         dedupe_key = f"agent_desc:{agent_id}"
         payload: Dict[str, Any] = {"agent_id": agent_id}

realign/logging_config.py

@@ -7,11 +7,15 @@ Supports file rotation, environment variable configuration, and structured loggi
 
 import logging
 import os
+import tempfile
 from pathlib import Path
 from logging.handlers import RotatingFileHandler
 from typing import Optional
 
 
+_LOG_DIR_CACHE: tuple[str | None, Path] | None = None
+
+
 def get_log_level() -> int:
     """
     Get log level from environment variable or default to INFO.
@@ -46,17 +50,57 @@ def get_log_directory() -> Path:
     Returns:
         Path: Log directory path
     """
+    global _LOG_DIR_CACHE
+
     log_dir_str = os.getenv("REALIGN_LOG_DIR")
+    if _LOG_DIR_CACHE is not None and _LOG_DIR_CACHE[0] == log_dir_str:
+        return _LOG_DIR_CACHE[1]
 
+    candidates: list[Path] = []
     if log_dir_str:
-        log_dir = Path(log_dir_str).expanduser()
+        candidates.append(Path(log_dir_str).expanduser())
     else:
-        log_dir = Path.home() / ".aline" / ".logs"
+        candidates.append(Path.home() / ".aline" / ".logs")
 
-    # Create directory if it doesn't exist
-    log_dir.mkdir(parents=True, exist_ok=True)
+    # Fallback for restricted environments (e.g., sandboxed runners).
+    candidates.append(Path(tempfile.gettempdir()) / "aline-logs")
 
-    return log_dir
+    def can_write_files(directory: Path) -> bool:
+        try:
+            directory.mkdir(parents=True, exist_ok=True)
+            probe = directory / f".write_probe_{os.getpid()}_{os.urandom(4).hex()}"
+            probe.write_text("ok", encoding="utf-8")
+            probe.unlink(missing_ok=True)
+            return True
+        except Exception:
+            return False
+
+    last_error: Exception | None = None
+    for candidate in candidates:
+        try:
+            if can_write_files(candidate):
+                _LOG_DIR_CACHE = (log_dir_str, candidate)
+                return candidate
+        except Exception as e:
+            last_error = e
+            continue
+
+    # Last resort: current working directory (best-effort, avoids crashing).
+    try:
+        cwd = Path.cwd() / ".aline-logs"
+        if can_write_files(cwd):
+            _LOG_DIR_CACHE = (log_dir_str, cwd)
+            return cwd
+        return cwd
+    except Exception:
+        # If even this fails, return the first candidate to keep callers deterministic.
+        # The logger will fall back to stderr-only.
+        if last_error:
+            chosen = candidates[0]
+        else:
+            chosen = Path.cwd()
+        _LOG_DIR_CACHE = (log_dir_str, chosen)
+        return chosen
 
 
 def setup_logger(
@@ -86,8 +130,9 @@ def setup_logger(
     """
     logger = logging.getLogger(name)
 
-    # Only configure if not already configured
     if logger.handlers:
+        # Keep logger level in sync with env var, but avoid duplicating handlers.
+        logger.setLevel(get_log_level())
         return logger
 
     logger.setLevel(get_log_level())