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

realign/codex_hooks/notify_hook_installer.py

@@ -0,0 +1,247 @@
+"""
+Codex notify hook installer (best-effort).
+
+We primarily support the Rust Codex CLI which reads CODEX_HOME/config.toml and
+supports `notify = "command args..."` to run a script when a turn finishes.
+
+For legacy Codex config.yaml/config.json formats, we can only set `notify: true`
+to enable built-in notifications; there is no guaranteed script hook in that format.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+from ..logging_config import setup_logger
+
+logger = setup_logger("realign.codex_hooks.installer", "codex_hooks_installer.log")
+
+ALINE_HOOK_MARKER = "aline-codex-notify-hook"
+
+
+def get_notify_hook_script_path() -> Path:
+    return Path(__file__).parent / "notify_hook.py"
+
+
+def get_notify_hook_command_parts() -> list[str]:
+    script_path = get_notify_hook_script_path()
+    return [sys.executable, str(script_path)]
+
+
+def _toml_escape(s: str) -> str:
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def _format_notify_toml(cmd: list[str]) -> str:
+    # Codex CLI expects notify as a string (shell command), not an array.
+    # NOTE: we intentionally do not attempt complex quoting here; the common case is
+    # paths without spaces (e.g. /opt/homebrew/...).
+    command_str = " ".join(cmd)
+    return f"notify = \"{_toml_escape(command_str)}\"  # {ALINE_HOOK_MARKER}\n"
+
+
+def _update_toml_linewise(path: Path, *, cmd: list[str]) -> bool:
+    """
+    Update config.toml in a minimal, formatting-preserving way (line-based).
+
+    Returns True if the file was written/updated.
+    """
+    desired = _format_notify_toml(cmd)
+    existing = ""
+    try:
+        existing = path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        existing = ""
+    except Exception:
+        return False
+
+    lines = existing.splitlines(keepends=True) if existing else []
+    out: list[str] = []
+    replaced = False
+
+    for line in lines:
+        stripped = line.lstrip()
+        if stripped.startswith("notify ="):
+            if not replaced:
+                out.append(desired)
+                replaced = True
+            else:
+                # Drop duplicate notify lines.
+                continue
+        else:
+            out.append(line)
+
+    if not replaced:
+        if out and not out[-1].endswith("\n"):
+            out[-1] = out[-1] + "\n"
+        if out and out[-1].strip():
+            out.append("\n")
+        out.append(desired)
+
+    new_text = "".join(out)
+    if new_text == existing:
+        return True
+
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(new_text, encoding="utf-8")
+        return True
+    except Exception:
+        return False
+
+
+def _ensure_legacy_notify_enabled(codex_home: Path) -> list[Path]:
+    """
+    Best-effort for legacy Codex config formats (YAML/JSON):
+    set `notify: true` / `"notify": true` if the file exists.
+    """
+    updated: list[Path] = []
+    yaml_path = codex_home / "config.yaml"
+    json_path = codex_home / "config.json"
+
+    if yaml_path.exists():
+        try:
+            raw = yaml_path.read_text(encoding="utf-8")
+            if "notify:" in raw:
+                # Minimal replace: notify: <anything> -> notify: true
+                out_lines: list[str] = []
+                for line in raw.splitlines():
+                    if line.strip().startswith("notify:"):
+                        out_lines.append("notify: true")
+                    else:
+                        out_lines.append(line)
+                new_raw = "\n".join(out_lines) + ("\n" if raw.endswith("\n") else "")
+            else:
+                new_raw = raw + ("\n" if raw and not raw.endswith("\n") else "") + "notify: true\n"
+            if new_raw != raw:
+                yaml_path.write_text(new_raw, encoding="utf-8")
+            updated.append(yaml_path)
+        except Exception:
+            pass
+
+    if json_path.exists():
+        try:
+            obj = json.loads(json_path.read_text(encoding="utf-8") or "{}")
+            if isinstance(obj, dict):
+                if obj.get("notify") is not True:
+                    obj["notify"] = True
+                    json_path.write_text(json.dumps(obj, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+                updated.append(json_path)
+        except Exception:
+            pass
+
+    return updated
+
+
+def ensure_notify_hook_installed_for_codex_home(
+    codex_home: Path, *, quiet: bool = True
+) -> bool:
+    """
+    Ensure the notify hook is installed for a given CODEX_HOME.
+
+    - Rust CLI: writes/updates CODEX_HOME/config.toml notify command.
+    - Legacy: enables notify=true if config.yaml/config.json exist.
+    """
+    codex_home = Path(codex_home).expanduser()
+    cmd = get_notify_hook_command_parts()
+
+    ok = False
+    toml_path = codex_home / "config.toml"
+    if _update_toml_linewise(toml_path, cmd=cmd):
+        ok = True
+        if not quiet:
+            print(f"[Aline] Codex notify hook installed: {toml_path}", file=sys.stderr)
+    _ensure_legacy_notify_enabled(codex_home)
+    return ok
+
+
+def ensure_global_codex_notify_hook_installed(*, quiet: bool = True) -> bool:
+    """Best-effort: install notify hook into default global CODEX_HOME (~/.codex)."""
+    return ensure_notify_hook_installed_for_codex_home(Path.home() / ".codex", quiet=quiet)
+
+
+def ensure_all_aline_codex_homes_notify_hook_installed(*, quiet: bool = True) -> int:
+    """
+    Best-effort: install notify hook into every Aline-managed CODEX_HOME under ~/.aline/codex_homes.
+    Returns number of homes updated.
+    """
+    try:
+        from ..codex_home import aline_codex_homes_dir
+
+        root = aline_codex_homes_dir()
+    except Exception:
+        root = Path.home() / ".aline" / "codex_homes"
+
+    if not root.exists():
+        return 0
+
+    updated = 0
+    for child in root.iterdir():
+        if not child.is_dir():
+            continue
+        # Layouts:
+        # - <terminal_id>/
+        # - agent-<id>/<terminal_id>/
+        if child.name.startswith("agent-"):
+            try:
+                for grandchild in child.iterdir():
+                    if grandchild.is_dir():
+                        if ensure_notify_hook_installed_for_codex_home(grandchild, quiet=quiet):
+                            updated += 1
+            except Exception:
+                continue
+        else:
+            if ensure_notify_hook_installed_for_codex_home(child, quiet=quiet):
+                updated += 1
+    return updated
+
+
+def codex_cli_supports_notify_hook(*, timeout_seconds: float = 0.5) -> Optional[bool]:
+    """
+    Best-effort detect whether the installed `codex` binary supports the Rust notify hook.
+
+    Returns:
+      - True: looks like Rust Codex CLI (supports config.toml + notify command)
+      - False: looks like legacy Codex (no reliable script notify hook)
+      - None: codex binary not found
+    """
+    if shutil.which("codex") is None:
+        return None
+
+    def run(args: list[str]) -> str:
+        try:
+            proc = subprocess.run(
+                args,
+                text=True,
+                capture_output=True,
+                check=False,
+                timeout=float(timeout_seconds),
+            )
+            return f"{proc.stdout}\n{proc.stderr}".strip().lower()
+        except Exception:
+            return ""
+
+    help_out = run(["codex", "--help"])
+    ver_out = run(["codex", "--version"])
+    out = (help_out + "\n" + ver_out).lower()
+
+    # Strong positive indicators for Rust CLI.
+    if "config.toml" in out and "notify" in out:
+        return True
+    # Avoid false positives (e.g. "trusted" contains the substring "rust").
+    if "codex-rs" in out or re.search(r"\brust\b", out):
+        return True
+
+    # Legacy indicators (YAML/JSON config keys from older docs/CLI).
+    if "config.yaml" in out or "approvalmode" in out or "fullautoerrormode" in out:
+        return False
+
+    # Conservative default: if we cannot confirm, treat as unsupported so we don't
+    # claim Codex integration works when it won't.
+    return False

realign/commands/doctor.py

@@ -131,6 +131,27 @@ def _update_claude_hooks(*, verbose: bool) -> Tuple[list[str], list[str]]:
     return hooks_updated, hooks_failed
 
 
+def _update_codex_notify_hook(*, verbose: bool) -> Tuple[int, int]:
+    """
+    Ensure Codex notify hook is installed:
+    - global ~/.codex
+    - all Aline-managed ~/.aline/codex_homes/*
+    """
+    try:
+        from ..codex_hooks.notify_hook_installer import (
+            ensure_all_aline_codex_homes_notify_hook_installed,
+            ensure_global_codex_notify_hook_installed,
+        )
+
+        ok_global = 1 if ensure_global_codex_notify_hook_installed(quiet=not verbose) else 0
+        ok_homes = int(ensure_all_aline_codex_homes_notify_hook_installed(quiet=not verbose))
+        return ok_global, ok_homes
+    except Exception as e:
+        if verbose:
+            console.print(f"  [yellow]Codex notify hook update failed: {e}[/yellow]")
+        return 0, 0
+
+
 def _update_skills(*, verbose: bool) -> int:
     from .add import add_skills_command
 
@@ -302,6 +323,66 @@ def _check_llm_error_turns(
         db.close()
 
 
+def _check_watcher_backlog(
+    config: ReAlignConfig,
+    *,
+    verbose: bool,
+    fix: bool,
+) -> Tuple[int, int]:
+    """
+    Check for backlog sessions that changed since the watcher last run.
+
+    Uses the same 2-phase startup scan logic as the watcher:
+    1) stat previously persisted session paths (fast)
+    2) full scan of watch paths (complete)
+    """
+    from ..db.sqlite_db import SQLiteDatabase
+    from ..watcher_core import DialogueWatcher
+
+    db_path = Path(config.sqlite_db_path).expanduser()
+    if not db_path.exists():
+        return 0, 0
+
+    watcher = DialogueWatcher()
+    candidates, _sizes, _mtimes, report = watcher._startup_scan_collect_candidates()
+
+    if verbose:
+        console.print(
+            f"  [dim]Tracked paths: {report.prev_paths} (missing: {report.prev_missing}, changed: {report.prev_changed})[/dim]"
+        )
+        console.print(
+            f"  [dim]Scan paths: {report.scan_paths} (new: {report.scan_new}, changed: {report.scan_changed})[/dim]"
+        )
+
+    if not candidates:
+        return 0, 0
+
+    if not fix:
+        return len(candidates), 0
+
+    db = SQLiteDatabase(str(db_path))
+    try:
+        enqueued = 0
+        for session_file in candidates:
+            try:
+                db.enqueue_session_process_job(
+                    session_file_path=session_file,
+                    session_id=session_file.stem,
+                    workspace_path=None,
+                    session_type=watcher._detect_session_type(session_file),
+                    source_event="doctor_backlog_scan",
+                    priority=getattr(watcher, "_startup_scan_priority", 5),
+                )
+                enqueued += 1
+            except Exception as e:
+                if verbose:
+                    console.print(f"  [yellow]Failed to enqueue {session_file}: {e}[/yellow]")
+                continue
+        return len(candidates), enqueued
+    finally:
+        db.close()
+
+
 def run_doctor(
     *,
     restart_daemons: bool,
@@ -389,6 +470,34 @@ def run_doctor(
     if hooks_failed:
         console.print(f"  [yellow]![/yellow] Failed hooks: {', '.join(hooks_failed)}")
 
+    # 3b. Update Codex notify hook
+    console.print("\n[bold]3b. Updating Codex notify hook...[/bold]")
+    try:
+        ok_global, ok_homes = _update_codex_notify_hook(verbose=verbose)
+        if ok_global:
+            console.print("  [green]✓[/green] Updated global Codex config (~/.codex)")
+        else:
+            console.print("  [dim]Global Codex config not updated (may be missing or unwritable)[/dim]")
+        if ok_homes:
+            console.print(f"  [green]✓[/green] Updated {ok_homes} Aline CODEX_HOME(s)")
+        else:
+            console.print("  [dim]No Aline CODEX_HOME(s) updated[/dim]")
+
+        # If Codex exists but is legacy, warn: Aline expects the Rust notify hook.
+        try:
+            from ..codex_hooks.notify_hook_installer import codex_cli_supports_notify_hook
+
+            supported = codex_cli_supports_notify_hook()
+            if supported is False:
+                console.print("  [yellow]![/yellow] Codex CLI does not support notify hook.")
+                console.print(
+                    "  [dim]Tip: update to the Rust Codex CLI to enable reliable, event-driven Codex imports.[/dim]"
+                )
+        except Exception:
+            pass
+    except Exception as e:
+        console.print(f"  [yellow]![/yellow] Codex notify hook update failed: {e}")
+
     # 4. Update skills
     console.print("\n[bold]4. Updating skills...[/bold]")
     try:
@@ -446,6 +555,22 @@ def run_doctor(
     except Exception as e:
         console.print(f"  [yellow]![/yellow] Failed to repair associations: {e}")
 
+    # 5c. Check backlog sessions (watcher startup scan semantics)
+    console.print("\n[bold]5c. Checking watcher backlog sessions...[/bold]")
+    try:
+        backlog_count, _ = _check_watcher_backlog(config, verbose=verbose, fix=False)
+        if backlog_count == 0:
+            console.print("  [green]✓[/green] No backlog sessions detected")
+        else:
+            console.print(f"  [yellow]![/yellow] Found {backlog_count} backlog session(s) to process")
+            if auto_fix or typer.confirm("\n  Do you want to enqueue these for processing now?", default=True):
+                _, enqueued = _check_watcher_backlog(config, verbose=verbose, fix=True)
+                console.print(f"  [green]✓[/green] Enqueued {enqueued} session_process job(s)")
+            else:
+                console.print("  [dim]Skipped enqueueing backlog sessions[/dim]")
+    except Exception as e:
+        console.print(f"  [yellow]![/yellow] Failed to check watcher backlog: {e}")
+
     # 6. Restart/ensure daemons
     if restart_daemons:
         console.print("\n[bold]6. Checking daemons...[/bold]")

realign/commands/import_shares.py

@@ -47,6 +47,7 @@ else:
 def download_share_data(
     share_url: str,
     password: Optional[str] = None,
+    cache_buster: Optional[str] = None,
 ) -> Dict[str, Any]:
     """
     Download share data from a share URL.
@@ -62,7 +63,10 @@ def download_share_data(
         {"success": False, "error": str} on failure
     """
     if not HTTPX_AVAILABLE:
-        return {"success": False, "error": "httpx package not installed. Install with: pip install httpx"}
+        return {
+            "success": False,
+            "error": "httpx package not installed. Install with: pip install httpx",
+        }
 
     share_id = extract_share_id(share_url)
     if not share_id:
@@ -101,14 +105,16 @@ def download_share_data(
 
     # Download export data
     try:
-        export_response = httpx.get(
-            f"{backend_url}/api/share/{share_id}/export", headers=headers, timeout=30.0
-        )
+        export_url = f"{backend_url}/api/share/{share_id}/export"
+        if cache_buster:
+            export_url = f"{export_url}?cache_bust={cache_buster}"
+
+        export_response = httpx.get(export_url, headers=headers, timeout=30.0)
         export_data = export_response.json()
 
         if export_response.status_code == 413 or export_data.get("needs_chunked_download"):
             total_chunks = export_data.get("total_chunks", 1)
-            raw_data = _download_chunks(backend_url, share_id, headers, total_chunks)
+            raw_data = _download_chunks(backend_url, share_id, headers, total_chunks, cache_buster)
             conversation_data = json.loads(raw_data)
             export_data = {
                 "success": True,
@@ -494,7 +500,9 @@ def import_v2_data(
             share_url=share_url,
             commit_hashes=[],
             # V18: user identity (with backward compatibility for old format)
-            created_by=event_data.get("created_by") or event_data.get("uid") or event_data.get("creator_id"),
+            created_by=event_data.get("created_by")
+            or event_data.get("uid")
+            or event_data.get("creator_id"),
             shared_by=config.uid,  # Current user is the importer
         )
 
@@ -603,7 +611,9 @@ def import_session_with_turns(
             summary_locked_until=None,
             summary_error=None,
             # V18: user identity (with backward compatibility for old format)
-            created_by=session_data.get("created_by") or session_data.get("uid") or session_data.get("creator_id"),
+            created_by=session_data.get("created_by")
+            or session_data.get("uid")
+            or session_data.get("creator_id"),
             shared_by=config.uid,  # Current user is the importer
         )
 
@@ -833,7 +843,11 @@ def generate_content_hash(messages: List[Dict]) -> str:
 
 
 def _download_chunks(
-    backend_url: str, share_id: str, headers: Dict[str, str], total_chunks: int
+    backend_url: str,
+    share_id: str,
+    headers: Dict[str, str],
+    total_chunks: int,
+    cache_buster: Optional[str] = None,
 ) -> str:
     """
     Download data in chunks and combine them.
@@ -854,8 +868,11 @@ def _download_chunks(
             task = progress.add_task("[cyan]Downloading chunks...", total=total_chunks)
 
             for i in range(total_chunks):
+                url = f"{backend_url}/api/share/{share_id}/export?chunk={i}"
+                if cache_buster:
+                    url = f"{url}&cache_bust={cache_buster}"
                 chunk_response = httpx.get(
-                    f"{backend_url}/api/share/{share_id}/export?chunk={i}",
+                    url,
                     headers=headers,
                     timeout=60.0,
                 )
@@ -876,8 +893,11 @@ def _download_chunks(
         for i in range(total_chunks):
             print(f"Downloading chunk {i + 1}/{total_chunks}...")
 
+            url = f"{backend_url}/api/share/{share_id}/export?chunk={i}"
+            if cache_buster:
+                url = f"{url}&cache_bust={cache_buster}"
             chunk_response = httpx.get(
-                f"{backend_url}/api/share/{share_id}/export?chunk={i}",
+                url,
                 headers=headers,
                 timeout=60.0,
             )

realign/commands/init.py

@@ -836,6 +836,22 @@ def init_command(
     console.print(f"  Tmux: [cyan]{result.get('tmux_conf', 'N/A')}[/cyan]")
     console.print(f"  Skills: [cyan]{result.get('skills_path', 'N/A')}[/cyan]")
 
+    # Codex compatibility note (best-effort).
+    # We rely on the Rust Codex CLI notify hook to avoid expensive polling. If the installed
+    # Codex binary is legacy/unsupported, warn and suggest upgrading.
+    try:
+        from ..codex_hooks.notify_hook_installer import codex_cli_supports_notify_hook
+
+        supported = codex_cli_supports_notify_hook()
+        if supported is False:
+            console.print("\n[yellow]![/yellow] Codex CLI detected but does not support notify hook.")
+            console.print(
+                "[dim]Tip: update to the Rust Codex CLI to enable reliable, event-driven Codex imports (no polling).[/dim]"
+            )
+        # If Codex isn't installed (None), stay silent.
+    except Exception:
+        pass
+
     hooks_installed = result.get("hooks_installed") or []
     if hooks_installed:
         console.print(f"  Hooks: [cyan]{', '.join(hooks_installed)}[/cyan]")