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

realign/dashboard/app.py

@@ -1,8 +1,6 @@
 """Aline Dashboard - Main Application."""
 
 import os
-import subprocess
-import sys
 import time
 import traceback
 
@@ -16,6 +14,7 @@ from .widgets import (
     ConfigPanel,
     AgentsPanel,
 )
+from .state import get_dashboard_state_value
 
 # Environment variable to control terminal mode
 ENV_TERMINAL_MODE = "ALINE_TERMINAL_MODE"
@@ -24,27 +23,6 @@ ENV_TERMINAL_MODE = "ALINE_TERMINAL_MODE"
 logger = setup_logger("realign.dashboard", "dashboard.log")
 
 
-def _detect_system_dark_mode() -> bool:
-    """Detect if the system is in dark mode.
-
-    On macOS, checks AppleInterfaceStyle via defaults command.
-    Returns True for dark mode, False for light mode.
-    """
-    if sys.platform != "darwin":
-        return True  # Default to dark on non-macOS
-
-    try:
-        result = subprocess.run(
-            ["defaults", "read", "-g", "AppleInterfaceStyle"],
-            capture_output=True,
-            text=True,
-            timeout=1,
-        )
-        return result.stdout.strip().lower() == "dark"
-    except Exception:
-        return True  # Default to dark on error
-
-
 def _monotonic() -> float:
     """Small wrapper so tests can patch without affecting global time.monotonic()."""
     return time.monotonic()
@@ -78,9 +56,9 @@ class AlineDashboard(App):
         super().__init__()
         self.use_native_terminal = use_native_terminal
         self._native_terminal_mode = self._detect_native_mode()
-        logger.info(
-            f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})"
-        )
+        self._local_api_server = None
+        self._apply_saved_theme()
+        logger.info(f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})")
 
     def _detect_native_mode(self) -> bool:
         """Detect if native terminal mode should be used."""
@@ -110,14 +88,14 @@ class AlineDashboard(App):
         return ["agents", "config"]
 
     def on_mount(self) -> None:
-        """Apply theme based on system settings and watch for changes."""
+        """Apply dashboard theme based on saved preference."""
         logger.info("on_mount() started")
         try:
-            self._sync_theme()
-            # Check for system theme changes every 2 seconds
-            self.set_interval(2, self._sync_theme)
             self._quit_confirm_deadline: float | None = None
 
+            # Start local API server for one-click browser import
+            self._start_local_api_server()
+
             # Set up side-by-side layout for native terminal mode
             if self._native_terminal_mode:
                 self._setup_native_terminal_layout()
@@ -127,6 +105,25 @@ class AlineDashboard(App):
             logger.error(f"on_mount() failed: {e}\n{traceback.format_exc()}")
             raise
 
+    def _start_local_api_server(self) -> None:
+        """Start the local HTTP API server for browser-based agent import."""
+        try:
+            from ..config import ReAlignConfig
+            from .local_api import LocalAPIServer
+
+            config = ReAlignConfig.load()
+            self._local_api_server = LocalAPIServer(port=config.local_api_port)
+            self._local_api_server.start()
+        except Exception as e:
+            logger.warning(f"Could not start local API server: {e}")
+
+    def _apply_saved_theme(self) -> None:
+        theme_choice = str(get_dashboard_state_value("theme", "dark")).strip().lower()
+        if theme_choice == "light":
+            self.theme = "textual-light"
+        else:
+            self.theme = "textual-dark"
+
     def _setup_native_terminal_layout(self) -> None:
         """Set up side-by-side layout for Dashboard and native terminal."""
         # Skip if using iTerm2 split pane mode (already set up by CLI)
@@ -158,12 +155,6 @@ class AlineDashboard(App):
         except Exception as e:
             logger.warning(f"Could not set up native terminal layout: {e}")
 
-    def _sync_theme(self) -> None:
-        """Sync app theme with system theme."""
-        target_theme = "textual-dark" if _detect_system_dark_mode() else "textual-light"
-        if self.theme != target_theme:
-            self.theme = target_theme
-
     def action_next_tab(self) -> None:
         """Switch to next tab."""
         tabbed_content = self.query_one(TabbedContent)
@@ -211,6 +202,7 @@ class AlineDashboard(App):
         self._quit_confirm_deadline = now + self._quit_confirm_window_s
         self.notify("Press Ctrl+C again to quit", title="Quit", timeout=2)
 
+
 def run_dashboard(use_native_terminal: bool | None = None) -> None:
     """Run the Aline Dashboard.
 

realign/dashboard/local_api.py

@@ -0,0 +1,122 @@
+"""Local HTTP API server for one-click agent import from browser."""
+
+import json
+import threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+from ..logging_config import setup_logger
+
+logger = setup_logger("realign.dashboard.local_api", "local_api.log")
+
+ALLOWED_ORIGINS = [
+    "https://realign-server.vercel.app",
+    "http://localhost:3000",
+]
+
+
+class LocalAPIHandler(BaseHTTPRequestHandler):
+    """Handle local API requests from the browser."""
+
+    def _set_cors_headers(self) -> bool:
+        """Set CORS headers. Returns True if origin is allowed."""
+        origin = self.headers.get("Origin", "")
+        if origin in ALLOWED_ORIGINS:
+            self.send_header("Access-Control-Allow-Origin", origin)
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
+            return True
+        return False
+
+    def _send_json(self, status: int, data: dict) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self._set_cors_headers()
+        self.end_headers()
+        self.wfile.write(json.dumps(data).encode())
+
+    def do_OPTIONS(self) -> None:
+        """Handle CORS preflight."""
+        self.send_response(204)
+        self._set_cors_headers()
+        self.end_headers()
+
+    def do_GET(self) -> None:
+        if self.path == "/api/health":
+            self._send_json(200, {"status": "ok"})
+        else:
+            self._send_json(404, {"error": "not found"})
+
+    def do_POST(self) -> None:
+        if self.path == "/api/import-agent":
+            self._handle_import_agent()
+        else:
+            self._send_json(404, {"error": "not found"})
+
+    def _handle_import_agent(self) -> None:
+        try:
+            length = int(self.headers.get("Content-Length", 0))
+            body = json.loads(self.rfile.read(length)) if length else {}
+        except (json.JSONDecodeError, ValueError):
+            self._send_json(400, {"error": "invalid JSON body"})
+            return
+
+        share_url = body.get("share_url")
+        if not share_url:
+            self._send_json(400, {"error": "share_url is required"})
+            return
+
+        password = body.get("password")
+
+        logger.info(f"Import agent request: {share_url}")
+
+        try:
+            from ..commands.import_shares import import_agent_from_share
+
+            result = import_agent_from_share(share_url, password=password)
+            if result.get("success"):
+                logger.info(
+                    f"Agent imported: {result.get('agent_name')} "
+                    f"({result.get('sessions_imported')} sessions)"
+                )
+                self._send_json(200, result)
+            else:
+                logger.warning(f"Import failed: {result.get('error')}")
+                self._send_json(422, result)
+        except Exception as e:
+            logger.error(f"Import agent error: {e}", exc_info=True)
+            self._send_json(500, {"success": False, "error": str(e)})
+
+    def log_message(self, format: str, *args) -> None:
+        """Suppress default stderr logging; use our logger instead."""
+        logger.debug(f"HTTP {args[0] if args else ''}")
+
+
+class LocalAPIServer:
+    """Manages the local HTTP API server in a daemon thread."""
+
+    def __init__(self, port: int = 17280):
+        self.port = port
+        self._server: HTTPServer | None = None
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> bool:
+        """Start the server. Returns True on success."""
+        try:
+            self._server = HTTPServer(("127.0.0.1", self.port), LocalAPIHandler)
+            self._thread = threading.Thread(
+                target=self._server.serve_forever, daemon=True
+            )
+            self._thread.start()
+            logger.info(f"Local API server started on http://127.0.0.1:{self.port}")
+            return True
+        except OSError as e:
+            logger.warning(f"Failed to start local API server on port {self.port}: {e}")
+            return False
+
+    def stop(self) -> None:
+        """Stop the server."""
+        if self._server:
+            self._server.shutdown()
+            self._server = None
+            self._thread = None
+            logger.info("Local API server stopped")

realign/dashboard/screens/create_agent.py

@@ -15,9 +15,7 @@ from textual.containers import Container, Horizontal, Vertical
 from textual.screen import ModalScreen
 from textual.widgets import Button, Label, RadioButton, RadioSet, Static
 
-
-# State file for storing last workspace path
-DASHBOARD_STATE_FILE = Path.home() / ".aline" / "dashboard_state.json"
+from ..state import DASHBOARD_STATE_FILE, set_dashboard_state_value
 
 
 def _load_last_workspace() -> str:
@@ -80,14 +78,7 @@ def _save_claude_tracking_mode(mode: str) -> None:
 def _save_state(key: str, value: str) -> None:
     """Save a key-value pair to the state file."""
     try:
-        DASHBOARD_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-        state = {}
-        if DASHBOARD_STATE_FILE.exists():
-            with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
-                state = json.load(f)
-        state[key] = value
-        with open(DASHBOARD_STATE_FILE, "w", encoding="utf-8") as f:
-            json.dump(state, f, indent=2)
+        set_dashboard_state_value(key, value)
     except Exception:
         pass
 

realign/dashboard/state.py

@@ -0,0 +1,41 @@
+"""Small persistence helpers for dashboard UI state."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+DASHBOARD_STATE_FILE = Path.home() / ".aline" / "dashboard_state.json"
+
+
+def load_dashboard_state() -> dict[str, Any]:
+    try:
+        if not DASHBOARD_STATE_FILE.exists():
+            return {}
+        with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def save_dashboard_state(state: dict[str, Any]) -> None:
+    try:
+        DASHBOARD_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with open(DASHBOARD_STATE_FILE, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=2)
+    except Exception:
+        return
+
+
+def get_dashboard_state_value(key: str, default: Any) -> Any:  # noqa: ANN401
+    return load_dashboard_state().get(key, default)
+
+
+def set_dashboard_state_value(key: str, value: Any) -> None:  # noqa: ANN401
+    state = load_dashboard_state()
+    state[key] = value
+    save_dashboard_state(state)
+

realign/dashboard/tmux_manager.py

@@ -196,16 +196,17 @@ def _session_id_from_transcript_path(transcript_path: str | None) -> str | None:
 def _load_terminal_state_from_db() -> dict[str, dict[str, str]]:
     """Load terminal state from database (best-effort)."""
     import time as _time
+
     t0 = _time.time()
     try:
         from ..db import get_database
 
         t1 = _time.time()
         db = get_database(read_only=True)
-        logger.info(f"[PERF] _load_terminal_state_from_db get_database: {_time.time() - t1:.3f}s")
+        logger.debug(f"[PERF] _load_terminal_state_from_db get_database: {_time.time() - t1:.3f}s")
         t2 = _time.time()
         agents = db.list_agents(status="active", limit=100)
-        logger.info(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
+        logger.debug(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
 
         out: dict[str, dict[str, str]] = {}
         for agent in agents:
@@ -711,13 +712,14 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
 
 def list_inner_windows() -> list[InnerWindow]:
     import time as _time
+
     t0 = _time.time()
     if not ensure_inner_session():
         return []
-    logger.info(f"[PERF] list_inner_windows ensure_inner_session: {_time.time() - t0:.3f}s")
+    logger.debug(f"[PERF] list_inner_windows ensure_inner_session: {_time.time() - t0:.3f}s")
     t1 = _time.time()
     state = _load_terminal_state()
-    logger.info(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
+    logger.debug(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
     out = (
         _run_inner_tmux(
             [
@@ -840,6 +842,7 @@ def list_inner_windows() -> list[InnerWindow]:
 
 def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
     import time as _time
+
     if not ensure_inner_session():
         return False
     ok = True
@@ -848,7 +851,7 @@ def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
         # Important: these are per-window (not session-wide) to avoid cross-tab clobbering.
         if _run_inner_tmux(["set-option", "-w", "-t", window_id, key, value]).returncode != 0:
             ok = False
-        logger.info(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
+        logger.debug(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
     return ok
 
 
@@ -868,15 +871,16 @@ def create_inner_window(
     no_track: bool = False,
 ) -> InnerWindow | None:
     import time as _time
+
     t0 = _time.time()
-    logger.info(f"[PERF] create_inner_window START")
+    logger.debug("[PERF] create_inner_window START")
     if not ensure_right_pane():
         return None
-    logger.info(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
+    logger.debug(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
 
     t1 = _time.time()
     existing = list_inner_windows()
-    logger.info(f"[PERF] create_inner_window list_inner_windows: {_time.time() - t1:.3f}s")
+    logger.debug(f"[PERF] create_inner_window list_inner_windows: {_time.time() - t1:.3f}s")
     name = _unique_name((w.window_name for w in existing), base_name)
 
     # Record creation time before creating the window
@@ -897,7 +901,7 @@ def create_inner_window(
         ],
         capture=True,
     )
-    logger.info(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
+    logger.debug(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
     if proc.returncode != 0:
         return None
 
@@ -923,7 +927,7 @@ def create_inner_window(
         opts.setdefault(OPT_NO_TRACK, "")
     t3 = _time.time()
     set_inner_window_options(window_id, opts)
-    logger.info(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
+    logger.debug(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
 
     _run_inner_tmux(["select-window", "-t", window_id])
 
@@ -947,10 +951,7 @@ def select_inner_window(window_id: str) -> bool:
 def focus_right_pane() -> bool:
     """Focus the right pane (terminal area) in the outer tmux layout."""
     return (
-        _run_outer_tmux(
-            ["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]
-        ).returncode
-        == 0
+        _run_outer_tmux(["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]).returncode == 0
     )