aline-ai 0.7.2__py3-none-any.whl → 0.7.4__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]")