nexo-brain 2.6.11 → 2.6.13

package/src/agent_runner.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+"""Terminal client launchers and headless automation backend runner."""
+
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from client_preferences import (
+    BACKEND_NONE,
+    CLIENT_CLAUDE_CODE,
+    CLIENT_CODEX,
+    TERMINAL_CLIENT_KEYS,
+    load_client_preferences,
+    resolve_automation_backend,
+    resolve_client_runtime_profile,
+    resolve_terminal_client,
+)
+
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+CLAUDE_LEGACY_MODEL_HINTS = {"opus", "sonnet"}
+
+
+class AgentRunnerError(RuntimeError):
+    """Base exception for runner failures."""
+
+
+class TerminalClientUnavailableError(AgentRunnerError):
+    """Raised when the requested interactive client cannot be launched."""
+
+
+class AutomationBackendUnavailableError(AgentRunnerError):
+    """Raised when the configured automation backend is unavailable."""
+
+
+def _resolve_claude_cli() -> str:
+    saved = NEXO_HOME / "config" / "claude-cli-path"
+    if saved.exists():
+        candidate = saved.read_text().strip()
+        if candidate and Path(candidate).exists():
+            return candidate
+    env_path = os.environ.get("CLAUDE_BIN", "").strip()
+    if env_path and Path(env_path).exists():
+        return env_path
+    discovered = shutil.which("claude")
+    if discovered:
+        return discovered
+    for candidate in (
+        Path.home() / ".local" / "bin" / "claude",
+        Path.home() / ".npm-global" / "bin" / "claude",
+        Path("/usr/local/bin/claude"),
+    ):
+        if candidate.exists():
+            return str(candidate)
+    return ""
+
+
+def _resolve_codex_cli() -> str:
+    env_path = os.environ.get("CODEX_BIN", "").strip()
+    if env_path and Path(env_path).exists():
+        return env_path
+    return shutil.which("codex") or ""
+
+
+def _headless_env(env: dict | None = None) -> dict:
+    merged = os.environ.copy()
+    if env:
+        merged.update(env)
+    merged["NEXO_HEADLESS"] = "1"
+    merged.pop("CLAUDECODE", None)
+    merged.pop("CLAUDE_CODE", None)
+    return merged
+
+
+def build_interactive_client_command(
+    *,
+    target: str | os.PathLike[str],
+    client: str | None = None,
+    preferences: dict | None = None,
+) -> tuple[str, list[str]]:
+    prefs = preferences or load_client_preferences()
+    selected = resolve_terminal_client(client, preferences=prefs)
+    target_path = str(Path(target).expanduser())
+    profile = resolve_client_runtime_profile(selected, preferences=prefs)
+
+    if selected == CLIENT_CLAUDE_CODE:
+        claude_bin = _resolve_claude_cli()
+        if not claude_bin:
+            raise TerminalClientUnavailableError(
+                "Claude Code launcher not found in PATH. Install `claude` first."
+            )
+        cmd = [claude_bin]
+        if profile["model"]:
+            cmd.extend(["--model", profile["model"]])
+        if profile["reasoning_effort"]:
+            cmd.extend(["--effort", profile["reasoning_effort"]])
+        cmd.extend(["--dangerously-skip-permissions", target_path])
+        return selected, cmd
+
+    if selected == CLIENT_CODEX:
+        codex_bin = _resolve_codex_cli()
+        if not codex_bin:
+            raise TerminalClientUnavailableError(
+                "Codex launcher not found in PATH. Install `codex` first or reconfigure NEXO."
+            )
+        cmd = [codex_bin]
+        if profile["model"]:
+            cmd.extend(["-m", profile["model"]])
+        if profile["reasoning_effort"]:
+            cmd.extend(["-c", f'model_reasoning_effort="{profile["reasoning_effort"]}"'])
+        cmd.extend(["-C", target_path])
+        return selected, cmd
+
+    raise TerminalClientUnavailableError(f"Unsupported terminal client: {selected}")
+
+
+def launch_interactive_client(
+    *,
+    target: str | os.PathLike[str],
+    client: str | None = None,
+    env: dict | None = None,
+    preferences: dict | None = None,
+) -> subprocess.CompletedProcess:
+    _, cmd = build_interactive_client_command(target=target, client=client, preferences=preferences)
+    launch_env = os.environ.copy()
+    if env:
+        launch_env.update(env)
+    return subprocess.run(cmd, env=launch_env)
+
+
+def _resolve_runtime_model_and_effort(
+    client: str,
+    *,
+    model: str | None = None,
+    reasoning_effort: str | None = None,
+    preferences: dict | None = None,
+) -> tuple[str, str]:
+    profile = resolve_client_runtime_profile(client, preferences=preferences)
+    requested_model = str(model or "").strip()
+    requested_effort = str(reasoning_effort or "").strip().lower()
+
+    if client == CLIENT_CODEX:
+        if not requested_model or requested_model.lower() in CLAUDE_LEGACY_MODEL_HINTS:
+            requested_model = profile["model"]
+    elif not requested_model:
+        requested_model = profile["model"]
+
+    if not requested_effort:
+        requested_effort = profile["reasoning_effort"]
+
+    return requested_model, requested_effort
+
+
+def _build_codex_prompt(
+    prompt: str,
+    *,
+    output_format: str = "",
+    append_system_prompt: str = "",
+    allowed_tools: str = "",
+) -> str:
+    instructions: list[str] = []
+    if append_system_prompt:
+        instructions.append(f"SYSTEM INSTRUCTIONS:\n{append_system_prompt}")
+    if output_format and output_format.lower() == "text":
+        instructions.append("FINAL RESPONSE FORMAT: plain text only.")
+    elif output_format:
+        instructions.append(f"FINAL RESPONSE FORMAT: {output_format}.")
+    if allowed_tools:
+        instructions.append(
+            "TOOLING SCOPE: Prefer to stay within capabilities equivalent to "
+            f"{allowed_tools} unless that would make the task fail."
+        )
+    if instructions:
+        return "\n\n".join([*instructions, prompt])
+    return prompt
+
+
+def run_automation_prompt(
+    prompt: str,
+    *,
+    backend: str | None = None,
+    cwd: str | os.PathLike[str] | None = None,
+    env: dict | None = None,
+    model: str = "",
+    reasoning_effort: str = "",
+    timeout: int = 300,
+    output_format: str = "",
+    append_system_prompt: str = "",
+    allowed_tools: str = "",
+    extra_args: list[str] | tuple[str, ...] | None = None,
+) -> subprocess.CompletedProcess:
+    prefs = load_client_preferences()
+    selected_backend = backend or resolve_automation_backend(preferences=prefs)
+    if selected_backend == BACKEND_NONE:
+        raise AutomationBackendUnavailableError("Automation backend is disabled in config.")
+
+    cwd_path = Path(cwd).expanduser().resolve() if cwd else Path.cwd()
+    run_env = _headless_env(env)
+    extra_args = list(extra_args or [])
+    resolved_model, resolved_effort = _resolve_runtime_model_and_effort(
+        selected_backend,
+        model=model,
+        reasoning_effort=reasoning_effort,
+        preferences=prefs,
+    )
+
+    if selected_backend == CLIENT_CLAUDE_CODE:
+        claude_bin = _resolve_claude_cli()
+        if not claude_bin:
+            raise AutomationBackendUnavailableError(
+                "Claude Code automation backend selected but `claude` is not installed."
+            )
+        cmd = [claude_bin, "-p", prompt]
+        if resolved_model:
+            cmd.extend(["--model", resolved_model])
+        if resolved_effort:
+            cmd.extend(["--effort", resolved_effort])
+        if output_format:
+            cmd.extend(["--output-format", output_format])
+        if append_system_prompt:
+            cmd.extend(["--append-system-prompt", append_system_prompt])
+        if allowed_tools:
+            cmd.extend(["--allowedTools", allowed_tools])
+        cmd.extend(extra_args)
+        return subprocess.run(
+            cmd,
+            cwd=str(cwd_path),
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env=run_env,
+        )
+
+    if selected_backend == CLIENT_CODEX:
+        codex_bin = _resolve_codex_cli()
+        if not codex_bin:
+            raise AutomationBackendUnavailableError(
+                "Codex automation backend selected but `codex` is not installed."
+            )
+        with tempfile.TemporaryDirectory(prefix="nexo-codex-") as tmpdir:
+            output_path = Path(tmpdir) / "last-message.txt"
+            cmd = [
+                codex_bin,
+                "exec",
+                "--skip-git-repo-check",
+                "--dangerously-bypass-approvals-and-sandbox",
+                "--ephemeral",
+                "-C",
+                str(cwd_path),
+                "-o",
+                str(output_path),
+            ]
+            if resolved_model:
+                cmd.extend(["-m", resolved_model])
+            if resolved_effort:
+                cmd.extend(["-c", f'model_reasoning_effort="{resolved_effort}"'])
+            cmd.extend(extra_args)
+            cmd.append(
+                _build_codex_prompt(
+                    prompt,
+                    output_format=output_format,
+                    append_system_prompt=append_system_prompt,
+                    allowed_tools=allowed_tools,
+                )
+            )
+            result = subprocess.run(
+                cmd,
+                cwd=str(cwd_path),
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                env=run_env,
+            )
+            stdout = output_path.read_text() if output_path.exists() else (result.stdout or "")
+            return subprocess.CompletedProcess(
+                cmd,
+                result.returncode,
+                stdout,
+                result.stderr,
+            )
+
+    raise AutomationBackendUnavailableError(f"Unsupported automation backend: {selected_backend}")
+
+
+def probe_automation_backend(
+    *,
+    backend: str | None = None,
+    cwd: str | os.PathLike[str] | None = None,
+    timeout: int = 60,
+) -> dict:
+    selected_backend = backend or resolve_automation_backend()
+    if selected_backend == BACKEND_NONE:
+        return {
+            "ok": False,
+            "backend": BACKEND_NONE,
+            "reason": "automation disabled in config",
+        }
+    try:
+        result = run_automation_prompt(
+            "Reply exactly OK.",
+            backend=selected_backend,
+            cwd=cwd,
+            timeout=timeout,
+            output_format="text",
+        )
+    except AutomationBackendUnavailableError as exc:
+        return {
+            "ok": False,
+            "backend": selected_backend,
+            "reason": str(exc),
+        }
+    output = (result.stdout or "").strip()
+    return {
+        "ok": result.returncode == 0 and "OK" in output,
+        "backend": selected_backend,
+        "returncode": result.returncode,
+        "stdout": output,
+        "stderr": (result.stderr or "").strip(),
+    }

package/src/auto_update.py

@@ -933,7 +933,7 @@ def auto_update_check() -> dict:
 
     # Backfill runtime CLI modules for existing installs
     try:
-        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py"):
+        for fname in ("cli.py", "script_registry.py", "skills_runtime.py", "cron_recovery.py", "client_preferences.py", "agent_runner.py"):
             src_file = SRC_DIR / fname
             dest_file = NEXO_HOME / fname
             if src_file.is_file() and (not dest_file.exists() or src_file.stat().st_mtime > dest_file.stat().st_mtime):
@@ -1198,6 +1198,7 @@ def _backup_runtime_tree(dest: Path = NEXO_HOME) -> str:
         "maintenance.py", "storage_router.py", "claim_graph.py", "hnsw_index.py",
         "evolution_cycle.py", "migrate_embeddings.py", "auto_close_sessions.py",
         "client_sync.py",
+        "client_preferences.py", "agent_runner.py",
         "auto_update.py", "tools_sessions.py", "tools_coordination.py",
         "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
         "tools_credentials.py", "tools_task_history.py", "tools_menu.py",
@@ -1247,6 +1248,7 @@ def _copy_runtime_from_source(src_dir: Path, repo_dir: Path, dest: Path = NEXO_H
         "maintenance.py", "storage_router.py", "claim_graph.py", "hnsw_index.py",
         "evolution_cycle.py", "migrate_embeddings.py", "auto_close_sessions.py",
         "client_sync.py",
+        "client_preferences.py", "agent_runner.py",
         "auto_update.py", "tools_sessions.py", "tools_coordination.py",
         "tools_reminders.py", "tools_reminders_crud.py", "tools_learnings.py",
         "tools_credentials.py", "tools_task_history.py", "tools_menu.py",
@@ -1446,8 +1448,15 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     _emit_progress(progress_fn, "Refreshing shared client configs...")
     try:
         from client_sync import sync_all_clients
-
-        client_sync_result = sync_all_clients(nexo_home=dest, runtime_root=dest)
+        from client_preferences import normalize_client_preferences
+
+        schedule_path = dest / "config" / "schedule.json"
+        schedule_payload = json.loads(schedule_path.read_text()) if schedule_path.exists() else {}
+        client_sync_result = sync_all_clients(
+            nexo_home=dest,
+            runtime_root=dest,
+            preferences=normalize_client_preferences(schedule_payload),
+        )
         if client_sync_result.get("ok"):
             actions.append("client-sync")
         else:

package/src/cli.py

@@ -846,10 +846,6 @@ def _dashboard(args):
 
 def _chat(args):
     target = args.path or "."
-    claude_bin = os.environ.get("CLAUDE_BIN") or shutil.which("claude")
-    if not claude_bin:
-        print("Claude Code launcher not found in PATH. Install `claude` first.", file=sys.stderr)
-        return 1
 
     try:
         from auto_update import startup_preflight
@@ -868,10 +864,21 @@ def _chat(args):
     except Exception:
         pass
 
-    result = subprocess.run(
-        [claude_bin, "--dangerously-skip-permissions", target],
-        env=os.environ.copy(),
-    )
+    try:
+        from agent_runner import TerminalClientUnavailableError, launch_interactive_client
+    except ImportError:
+        print("Agent runner module not found. Ensure NEXO is properly installed.", file=sys.stderr)
+        return 1
+
+    try:
+        result = launch_interactive_client(
+            target=target,
+            client=getattr(args, "client", None),
+            env=os.environ.copy(),
+        )
+    except TerminalClientUnavailableError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
     return int(result.returncode)
 
 
@@ -1005,7 +1012,7 @@ def _print_help():
     print(f"""NEXO Runtime CLI v{v}
 
 Commands:
-  nexo chat [path]                                    Launch Claude Code
+  nexo chat [path] [--client claude_code|codex]      Launch the selected terminal client
   nexo doctor [--tier boot|runtime|deep|all] [--fix]   System diagnostics
   nexo scripts list|create|classify|sync|reconcile|ensure-schedules|schedules|run|doctor|call|unschedule|remove
                                                       Personal scripts
@@ -1027,8 +1034,13 @@ def main():
     sub = parser.add_subparsers(dest="command")
 
     # -- chat --
-    chat_parser = sub.add_parser("chat", help="Launch Claude Code")
+    chat_parser = sub.add_parser("chat", help="Launch the selected terminal client")
     chat_parser.add_argument("path", nargs="?", default=".", help="Working directory (default: current directory)")
+    chat_parser.add_argument(
+        "--client",
+        choices=["claude_code", "codex"],
+        help="Override the configured default terminal client",
+    )
 
     # -- scripts --
     scripts_parser = sub.add_parser("scripts", help="Manage personal scripts")