aline-ai 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

realign/codex_detector.py

@@ -7,6 +7,42 @@ from pathlib import Path
 from typing import Optional, List
 
 
+def _codex_session_roots() -> list[Path]:
+    """Return all Codex session root directories to scan (best-effort)."""
+    roots: list[Path] = []
+
+    # Default Codex home: ~/.codex/sessions
+    roots.append(Path.home() / ".codex" / "sessions")
+
+    # Aline-managed per-terminal CODEX_HOME isolation: ~/.aline/codex_homes/*/sessions
+    try:
+        from .codex_home import aline_codex_homes_dir, codex_sessions_dir_for_home
+
+        homes = aline_codex_homes_dir()
+        if homes.exists():
+            for child in homes.iterdir():
+                if child.is_dir():
+                    roots.append(codex_sessions_dir_for_home(child))
+    except Exception:
+        pass
+
+    # De-dup + only keep existing directories
+    out: list[Path] = []
+    seen: set[str] = set()
+    for r in roots:
+        try:
+            rr = r.expanduser()
+        except Exception:
+            rr = r
+        key = str(rr)
+        if key in seen:
+            continue
+        seen.add(key)
+        if rr.exists():
+            out.append(rr)
+    return out
+
+
 def find_codex_sessions_for_project(project_path: Path, days_back: int = 7) -> List[Path]:
     """
     Find Codex sessions for a given project path.
@@ -22,9 +58,8 @@ def find_codex_sessions_for_project(project_path: Path, days_back: int = 7) -> L
     Returns:
         List of session file paths that match the project, sorted by timestamp (newest first)
     """
-    codex_sessions_base = Path.home() / ".codex" / "sessions"
-
-    if not codex_sessions_base.exists():
+    codex_session_roots = _codex_session_roots()
+    if not codex_session_roots:
         return []
 
     # Normalize project path for comparison
@@ -32,36 +67,37 @@ def find_codex_sessions_for_project(project_path: Path, days_back: int = 7) -> L
 
     matching_sessions = []
 
-    # Search through recent days
-    for days_ago in range(days_back + 1):
-        target_date = datetime.now() - timedelta(days=days_ago)
-        date_path = (
-            codex_sessions_base
-            / str(target_date.year)
-            / f"{target_date.month:02d}"
-            / f"{target_date.day:02d}"
-        )
-
-        if not date_path.exists():
-            continue
-
-        # Check all session files in this date directory
-        for session_file in date_path.glob("rollout-*.jsonl"):
-            try:
-                # Read first line to get session metadata
-                with open(session_file, "r", encoding="utf-8") as f:
-                    first_line = f.readline()
-                    if first_line:
-                        data = json.loads(first_line)
-                        if data.get("type") == "session_meta":
-                            session_cwd = data.get("payload", {}).get("cwd", "")
-                            # Match the project path
-                            if session_cwd == abs_project_path:
-                                matching_sessions.append(session_file)
-            except (json.JSONDecodeError, IOError):
-                # Skip malformed or unreadable files
+    # Search through recent days in each root (YYYY/MM/DD layout).
+    for root in codex_session_roots:
+        for days_ago in range(days_back + 1):
+            target_date = datetime.now() - timedelta(days=days_ago)
+            date_path = (
+                root
+                / str(target_date.year)
+                / f"{target_date.month:02d}"
+                / f"{target_date.day:02d}"
+            )
+
+            if not date_path.exists():
                 continue
 
+            # Check all session files in this date directory
+            for session_file in date_path.glob("rollout-*.jsonl"):
+                try:
+                    # Read first line to get session metadata
+                    with open(session_file, "r", encoding="utf-8") as f:
+                        first_line = f.readline()
+                        if first_line:
+                            data = json.loads(first_line)
+                            if data.get("type") == "session_meta":
+                                session_cwd = data.get("payload", {}).get("cwd", "")
+                                # Match the project path
+                                if session_cwd == abs_project_path:
+                                    matching_sessions.append(session_file)
+                except (json.JSONDecodeError, IOError):
+                    # Skip malformed or unreadable files
+                    continue
+
     # Sort by modification time, newest first
     matching_sessions.sort(key=lambda p: p.stat().st_mtime, reverse=True)
 
@@ -90,8 +126,12 @@ def get_codex_sessions_dir() -> Optional[Path]:
     Returns:
         Path to ~/.codex/sessions if it exists, None otherwise
     """
+    # Preserve old API: return default location if present, else the first discovered root.
     codex_sessions = Path.home() / ".codex" / "sessions"
-    return codex_sessions if codex_sessions.exists() else None
+    if codex_sessions.exists():
+        return codex_sessions
+    roots = _codex_session_roots()
+    return roots[0] if roots else None
 
 
 def auto_detect_codex_sessions(

realign/codex_home.py

@@ -0,0 +1,85 @@
+"""Codex home/session path helpers.
+
+To guarantee terminal↔session binding even when multiple Codex instances run in the same cwd,
+we can isolate Codex storage per dashboard terminal via the `CODEX_HOME` environment variable.
+
+We choose deterministic paths under `~/.aline/` so the watcher (a separate process) can
+derive the owning terminal_id purely from the session file path.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+
+ENV_CODEX_HOME = "CODEX_HOME"
+
+
+def aline_codex_homes_dir() -> Path:
+    override = os.environ.get("ALINE_CODEX_HOMES_DIR", "").strip()
+    if override:
+        return Path(os.path.expanduser(override))
+    return Path.home() / ".aline" / "codex_homes"
+
+
+def codex_home_for_terminal(terminal_id: str) -> Path:
+    tid = (terminal_id or "").strip()
+    return aline_codex_homes_dir() / tid
+
+
+def codex_sessions_dir_for_home(codex_home: Path) -> Path:
+    return codex_home / "sessions"
+
+
+def codex_sessions_dir_for_terminal(terminal_id: str) -> Path:
+    return codex_sessions_dir_for_home(codex_home_for_terminal(terminal_id))
+
+
+def terminal_id_from_codex_session_file(session_file: Path) -> Optional[str]:
+    """If session_file is under an Aline-managed CODEX_HOME, return terminal_id."""
+    try:
+        homes = aline_codex_homes_dir().resolve()
+        p = session_file.resolve()
+    except Exception:
+        return None
+
+    try:
+        rel = p.relative_to(homes)
+    except ValueError:
+        return None
+
+    parts = rel.parts
+    if len(parts) < 3:
+        return None
+    terminal_id = (parts[0] or "").strip()
+    if not terminal_id:
+        return None
+    if parts[1] != "sessions":
+        return None
+    return terminal_id
+
+
+def prepare_codex_home(terminal_id: str) -> Path:
+    """Create/prepare an isolated CODEX_HOME for a terminal (best-effort)."""
+    home = codex_home_for_terminal(terminal_id)
+    sessions = codex_sessions_dir_for_home(home)
+    try:
+        sessions.mkdir(parents=True, exist_ok=True)
+    except Exception:
+        pass
+
+    # Keep Codex skills working under the isolated home by symlinking to the global skills dir.
+    try:
+        global_skills = Path.home() / ".codex" / "skills"
+        if global_skills.exists():
+            skills_link = home / "skills"
+            if not skills_link.exists():
+                skills_link.parent.mkdir(parents=True, exist_ok=True)
+                skills_link.symlink_to(global_skills)
+    except Exception:
+        pass
+
+    return home
+

realign/codex_terminal_linker.py

@@ -0,0 +1,172 @@
+"""Best-effort linking between Codex session files and Aline terminals.
+
+Claude Code provides explicit hook callbacks with session identifiers. Codex CLI does not,
+so we infer the binding by matching:
+- session_meta.cwd (project/workspace path)
+- session creation time vs. terminal creation time
+
+This module is intentionally dependency-light so it can be used by the watcher.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Iterable, Optional, Protocol
+
+
+@dataclass(frozen=True)
+class CodexSessionMeta:
+    session_file: Path
+    cwd: str
+    started_at: Optional[datetime] = None
+    originator: Optional[str] = None
+    source: Optional[str] = None
+
+
+def _parse_iso8601(ts: str) -> Optional[datetime]:
+    raw = (ts or "").strip()
+    if not raw:
+        return None
+    # Common Codex format: 2025-12-23T09:14:28.152Z
+    if raw.endswith("Z"):
+        raw = raw[:-1] + "+00:00"
+    try:
+        dt = datetime.fromisoformat(raw)
+    except ValueError:
+        return None
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
+def read_codex_session_meta(session_file: Path) -> Optional[CodexSessionMeta]:
+    """Extract Codex session metadata from a session file (best-effort)."""
+    try:
+        with session_file.open("r", encoding="utf-8") as f:
+            for i, line in enumerate(f):
+                if i >= 25:
+                    break
+                raw = (line or "").strip()
+                if not raw:
+                    continue
+                try:
+                    data = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+
+                # Typical format: {"type":"session_meta","payload":{...}}
+                if data.get("type") == "session_meta":
+                    payload = data.get("payload") or {}
+                    cwd = str(payload.get("cwd") or "").strip()
+                    if not cwd:
+                        return None
+                    started_at = _parse_iso8601(str(payload.get("timestamp") or ""))
+                    originator = str(payload.get("originator") or "").strip() or None
+                    source = str(payload.get("source") or "").strip() or None
+                    return CodexSessionMeta(
+                        session_file=session_file,
+                        cwd=cwd,
+                        started_at=started_at,
+                        originator=originator,
+                        source=source,
+                    )
+
+                # Newer Codex header: first line may have {id, timestamp, git} without "type"
+                if i == 0 and "timestamp" in data and "type" not in data:
+                    started_at = _parse_iso8601(str(data.get("timestamp") or ""))
+                    git = data.get("git") if isinstance(data.get("git"), dict) else {}
+                    cwd = ""
+                    if isinstance(git, dict):
+                        cwd = str(git.get("cwd") or "").strip()
+                    if not cwd:
+                        cwd = str(data.get("cwd") or "").strip()
+                    if not cwd:
+                        return None
+                    return CodexSessionMeta(session_file=session_file, cwd=cwd, started_at=started_at)
+    except OSError:
+        return None
+    except Exception:
+        return None
+
+    return None
+
+
+class _AgentLike(Protocol):
+    id: str
+    provider: str
+    status: str
+    cwd: Optional[str]
+    session_id: Optional[str]
+    transcript_path: Optional[str]
+    created_at: datetime
+
+
+def select_agent_for_codex_session(
+    agents: Iterable[_AgentLike],
+    *,
+    session: CodexSessionMeta,
+    max_time_delta_seconds: int = 6 * 60 * 60,
+) -> Optional[str]:
+    """Pick the best active Codex terminal for a Codex session file (best-effort)."""
+    cwd = (session.cwd or "").strip()
+    if not cwd:
+        return None
+
+    candidates: list[_AgentLike] = []
+    for a in agents:
+        try:
+            if getattr(a, "status", "") != "active":
+                continue
+            if getattr(a, "provider", "") != "codex":
+                continue
+            if (getattr(a, "cwd", None) or "").strip() != cwd:
+                continue
+            # Avoid clobbering an existing binding to a different session.
+            existing_sid = (getattr(a, "session_id", None) or "").strip()
+            if existing_sid and existing_sid != session.session_file.stem:
+                continue
+            existing_path = (getattr(a, "transcript_path", None) or "").strip()
+            if existing_path and existing_path != str(session.session_file):
+                continue
+            candidates.append(a)
+        except Exception:
+            continue
+
+    if not candidates:
+        return None
+    if len(candidates) == 1:
+        return candidates[0].id
+
+    # Pick closest by creation time.
+    if session.started_at is not None:
+        ref = session.started_at
+    else:
+        try:
+            ref = datetime.fromtimestamp(session.session_file.stat().st_mtime, tz=timezone.utc)
+        except OSError:
+            ref = datetime.now(tz=timezone.utc)
+
+    best_id: Optional[str] = None
+    best_delta: Optional[float] = None
+    for a in candidates:
+        try:
+            created_at = a.created_at
+            if created_at.tzinfo is None:
+                created_at = created_at.replace(tzinfo=timezone.utc)
+            delta = abs((ref - created_at).total_seconds())
+            if best_delta is None or delta < best_delta:
+                best_delta = delta
+                best_id = a.id
+        except Exception:
+            continue
+
+    if best_id is None:
+        return None
+    if best_delta is not None and best_delta > max_time_delta_seconds:
+        # Ambiguous: don't bind if terminals are too far from the session start.
+        return None
+    return best_id
+

realign/commands/__init__.py

@@ -1,5 +1,5 @@
 """ReAlign commands module."""
 
-from . import init, config
+from . import init, config, doctor
 
-__all__ = ["init", "config"]
+__all__ = ["init", "config", "doctor"]

realign/commands/add.py

@@ -2,8 +2,10 @@
 
 from __future__ import annotations
 
+import os
 import shutil
 import subprocess
+import sys
 from pathlib import Path
 
 from rich.console import Console
@@ -497,12 +499,60 @@ def _source_aline_tmux_conf(tmux_conf: Path) -> None:
             continue
 
 
-def add_tmux_command() -> int:
-    """Install tmux (via Homebrew) and set up Aline's tmux config."""
+def _find_brew() -> str | None:
     brew = shutil.which("brew")
+    return brew
+
+
+def _prompt_install_homebrew() -> bool:
+    if not sys.stdin.isatty():
+        console.print("[red]Homebrew not found.[/red]")
+        console.print("[dim]Install from https://brew.sh and retry.[/dim]")
+        return False
+
+    console.print("[yellow]Homebrew not found.[/yellow]")
+    console.print("[dim]Aline can install tmux automatically via Homebrew.[/dim]\n")
+    try:
+        answer = console.input("Install Homebrew now? ([green]y[/green]/[yellow]n[/yellow]): ").strip()
+    except (EOFError, KeyboardInterrupt):
+        return False
+    if answer.lower() not in ("y", "yes"):
+        console.print("[dim]Skipped Homebrew install.[/dim]")
+        console.print("[dim]Install from https://brew.sh and retry.[/dim]")
+        return False
+
+    console.print("\n[bold]Installing Homebrew (official script)...[/bold]")
+    console.print(
+        "[dim]Tip: if this fails, follow the manual steps at https://brew.sh[/dim]\n"
+    )
+    # Official install script (see https://brew.sh).
+    proc = subprocess.run(
+        [
+            "/bin/bash",
+            "-c",
+            "curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh | /bin/bash",
+        ],
+        text=True,
+        capture_output=False,
+        check=False,
+    )
+    if proc.returncode != 0:
+        console.print(f"[red]Failed:[/red] Homebrew install (exit {proc.returncode})")
+        return False
+    return True
+
+
+def add_tmux_command(*, install_brew: bool = False) -> int:
+    """Install tmux (via Homebrew) and set up Aline's tmux config."""
+    brew = _find_brew()
     if brew is None:
-        console.print("[red]Homebrew not found.[/red] Install from https://brew.sh and retry.")
-        return 1
+        if sys.platform == "darwin" and install_brew:
+            if not _prompt_install_homebrew():
+                return 1
+            brew = _find_brew()
+        if brew is None:
+            console.print("[red]Homebrew not found.[/red] Install from https://brew.sh and retry.")
+            return 1
 
     console.print("[dim]Running: brew install tmux[/dim]")
     proc = _run([brew, "install", "tmux"])
@@ -554,6 +604,25 @@ def _ensure_symlink(target_link: Path, source_file: Path, force: bool = False) -
     return True
 
 
+def _ensure_copy(target_file: Path, source_file: Path, force: bool = False) -> bool:
+    """Copy source_file to target_file.
+
+    Returns:
+        True if target was created/updated, False if skipped.
+    """
+    if target_file.exists() or target_file.is_symlink():
+        if not force:
+            return False
+        if target_file.is_dir() and not target_file.is_symlink():
+            shutil.rmtree(target_file)
+        else:
+            target_file.unlink()
+
+    target_file.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(source_file, target_file)
+    return True
+
+
 def add_skills_command(force: bool = False) -> int:
     """Install Aline skills for Claude Code and Codex.
 
@@ -567,10 +636,18 @@ def add_skills_command(force: bool = False) -> int:
         Exit code (0 for success, 1 for failure)
     """
     aline_skill_root = Path.home() / ".aline" / "skills"
+    codex_home_env = os.environ.get("CODEX_HOME", "").strip()
+    codex_home = Path.home() / ".codex"
+    if codex_home_env:
+        env_path = Path(codex_home_env).expanduser()
+        # Avoid installing into per-terminal isolated CODEX_HOME dirs.
+        if ".aline/codex_homes" not in str(env_path):
+            codex_home = env_path
     targets = [
-        ("Claude", Path.home() / ".claude" / "skills"),
-        ("Codex", Path.home() / ".codex" / "skills"),
-        ("OpenCode", Path.home() / ".config" / "opencode" / "skill"),
+        ("Claude", Path.home() / ".claude" / "skills", "symlink"),
+        # Codex skills are safer as real files: some environments/tools ignore symlinks.
+        ("Codex", codex_home / "skills", "copy"),
+        ("OpenCode", Path.home() / ".config" / "opencode" / "skill", "symlink"),
     ]
 
     installed_skills: list[str] = []
@@ -588,11 +665,14 @@ def add_skills_command(force: bool = False) -> int:
             continue
 
         # 2. Link to targets
-        for tool_name, tool_root in targets:
+        for tool_name, tool_root, mode in targets:
             dest_path = tool_root / skill_name / "SKILL.md"
 
             try:
-                updated = _ensure_symlink(dest_path, master_path, force)
+                if mode == "copy":
+                    updated = _ensure_copy(dest_path, master_path, force)
+                else:
+                    updated = _ensure_symlink(dest_path, master_path, force)
                 if updated:
                     installed_skills.append(f"{tool_name}/{skill_name}")
                 else: