codex-autorunner 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

codex_autorunner/codex_cli.py

@@ -1,84 +1,20 @@
-import subprocess
-from functools import lru_cache
-from typing import Iterable, Optional
-
-SUBCOMMAND_HINTS = ("exec", "resume")
-
-
-def extract_flag_value(args: Iterable[str], flag: str) -> Optional[str]:
-    if not args:
-        return None
-    for arg in args:
-        if not isinstance(arg, str):
-            continue
-        if arg.startswith(f"{flag}="):
-            return arg.split("=", 1)[1] or None
-    args_list = [str(a) for a in args]
-    for idx, arg in enumerate(args_list):
-        if arg == flag and idx + 1 < len(args_list):
-            return args_list[idx + 1]
-    return None
-
-
-def inject_flag(
-    args: Iterable[str],
-    flag: str,
-    value: Optional[str],
-    *,
-    subcommands: Iterable[str] = SUBCOMMAND_HINTS,
-) -> list[str]:
-    if not value:
-        return [str(a) for a in args]
-    args_list = [str(a) for a in args]
-    if extract_flag_value(args_list, flag):
-        return args_list
-    insert_at = None
-    for cmd in subcommands:
-        try:
-            insert_at = args_list.index(cmd)
-            break
-        except ValueError:
-            continue
-    if insert_at is None:
-        # `args` is sometimes a full argv that includes the binary at index 0,
-        # e.g. ["codex", "--yolo", ...]. In that case, never prepend flags before
-        # the binary or we'll turn argv[0] into e.g. "--model" and crash at spawn.
-        if args_list and not args_list[0].startswith("-"):
-            return [args_list[0], flag, value] + args_list[1:]
-        return [flag, value] + args_list
-    return args_list[:insert_at] + [flag, value] + args_list[insert_at:]
-
-
-def apply_codex_options(
-    args: Iterable[str],
-    *,
-    model: Optional[str] = None,
-    reasoning: Optional[str] = None,
-    supports_reasoning: Optional[bool] = None,
-) -> list[str]:
-    with_model = inject_flag(args, "--model", model)
-    if reasoning and supports_reasoning is False:
-        return with_model
-    return inject_flag(with_model, "--reasoning", reasoning)
-
-
-def _read_help_text(binary: str) -> str:
-    try:
-        result = subprocess.run(
-            [binary, "--help"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-    except FileNotFoundError:
-        return ""
-    return "\n".join(filter(None, [result.stdout, result.stderr]))
-
-
-@lru_cache(maxsize=8)
-def supports_flag(binary: str, flag: str) -> bool:
-    return flag in _read_help_text(binary)
-
-
-def supports_reasoning(binary: str) -> bool:
-    return supports_flag(binary, "--reasoning")
+"""Backward-compatible Codex CLI helpers.
+
+Delegates to core.utils to avoid duplicated logic.
+"""
+
+from .core.utils import (  # noqa: F401
+    apply_codex_options,
+    extract_flag_value,
+    inject_flag,
+    supports_flag,
+    supports_reasoning,
+)
+
+__all__ = [
+    "apply_codex_options",
+    "extract_flag_value",
+    "inject_flag",
+    "supports_flag",
+    "supports_reasoning",
+]

codex_autorunner/core/__init__.py

@@ -1 +1,5 @@
 """Core runtime primitives."""
+
+from .archive import ArchiveResult, archive_worktree_snapshot
+
+__all__ = ["ArchiveResult", "archive_worktree_snapshot"]

codex_autorunner/core/about_car.py

@@ -76,7 +76,8 @@ def build_about_car_markdown(
         "You are running inside **Codex Autorunner (CAR)**.\n\n"
         "CAR uses a ticket-first workflow.\n\n"
         "## Required for operation\n"
-        "- Tickets live under `.codex-autorunner/tickets/`.\n\n"
+        "- Tickets live under `.codex-autorunner/tickets/`.\n"
+        "- Lint ticket frontmatter after edits (runs against all tickets): `python3 .codex-autorunner/bin/lint_tickets.py`.\n\n"
         "## Optional workspace docs\n"
         "- **Active context**: "
         f"`{active_context_disp}`\n"
@@ -91,6 +92,10 @@ def build_about_car_markdown(
         "- **Dispatch**: An update or message from the agent.\n"
         "- **Handoff**: Passing control from agent to user (or vice versa).\n"
         "- **Inbox**: Where the agent receives files/messages.\n\n"
+        "## Ticket helpers\n"
+        "- Use `.codex-autorunner/bin/ticket_tool.py` to list/create/insert/move tickets; it is portable and venv-free.\n"
+        '- Common workflows: insert gap before N (`python3 .codex-autorunner/bin/ticket_tool.py insert --before N`); move a block (`... move --start A --end B --to T`); create with auto-quoted frontmatter (`... create --title "Fix #123" --agent codex`).\n'
+        "- After any ticket edits, lint all tickets: `python3 .codex-autorunner/bin/lint_tickets.py`.\n\n"
         "## How CAR works (short)\n"
         "- The web UI provides ticket editing + unified file chat.\n"
         "- `car serve` starts the hub web UI. The **Terminal** tab launches the configured `codex` binary in a PTY.\n"

codex_autorunner/core/app_server_ids.py

@@ -0,0 +1,59 @@
+from typing import Any, Optional
+
+
+def extract_turn_id(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for key in ("turnId", "turn_id", "id"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    turn = payload.get("turn")
+    if isinstance(turn, dict):
+        for key in ("id", "turnId", "turn_id"):
+            value = turn.get(key)
+            if isinstance(value, str):
+                return value
+    return None
+
+
+def _extract_thread_id_from_container(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for key in ("threadId", "thread_id"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    thread = payload.get("thread")
+    if isinstance(thread, dict):
+        for key in ("id", "threadId", "thread_id"):
+            value = thread.get(key)
+            if isinstance(value, str):
+                return value
+    return None
+
+
+def extract_thread_id_for_turn(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for candidate in (payload, payload.get("turn"), payload.get("item")):
+        thread_id = _extract_thread_id_from_container(candidate)
+        if thread_id:
+            return thread_id
+    return None
+
+
+def extract_thread_id(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for key in ("threadId", "thread_id", "id"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    thread = payload.get("thread")
+    if isinstance(thread, dict):
+        for key in ("id", "threadId", "thread_id"):
+            value = thread.get(key)
+            if isinstance(value, str):
+                return value
+    return None

codex_autorunner/core/app_server_threads.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import logging
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
@@ -17,6 +18,8 @@ FILE_CHAT_OPENCODE_KEY = "file_chat.opencode"
 FILE_CHAT_PREFIX = "file_chat."
 FILE_CHAT_OPENCODE_PREFIX = "file_chat.opencode."
 
+LOGGER = logging.getLogger("codex_autorunner.app_server")
+
 # Static keys that can be reset/managed via the UI.
 FEATURE_KEYS = {
     FILE_CHAT_KEY,
@@ -177,8 +180,14 @@ class AppServerThreadRegistry:
         try:
             atomic_write(self._notice_path(), json.dumps(notice, indent=2) + "\n")
         except Exception:
-            pass
+            LOGGER.warning(
+                "Failed to write app server thread corruption notice.",
+                exc_info=True,
+            )
         try:
             self._save_unlocked({})
         except Exception:
-            pass
+            LOGGER.warning(
+                "Failed to reset app server thread registry after corruption.",
+                exc_info=True,
+            )

codex_autorunner/core/app_server_utils.py

@@ -0,0 +1,165 @@
+import os
+from pathlib import Path
+from typing import Any, Optional, Sequence
+
+from .logging_utils import log_event
+from .utils import resolve_executable, subprocess_env
+
+
+def app_server_env(
+    command: Sequence[str],
+    cwd: Path,
+    *,
+    base_env: Optional[dict[str, str]] = None,
+) -> dict[str, str]:
+    extra_paths: list[str] = []
+    if command:
+        binary = command[0]
+        resolved = resolve_executable(binary, env=base_env)
+        candidate: Optional[Path] = Path(resolved) if resolved else None
+        if candidate is None:
+            candidate = Path(binary).expanduser()
+            if not candidate.is_absolute():
+                candidate = (cwd / candidate).resolve()
+        if candidate.exists():
+            extra_paths.append(str(candidate.parent))
+    return subprocess_env(extra_paths=extra_paths, base_env=base_env)
+
+
+def seed_codex_home(
+    codex_home: Path,
+    *,
+    logger: Any = None,
+    event_prefix: str = "app_server",
+) -> None:
+    logger = logger or __import__("logging").getLogger(__name__)
+    auth_path = codex_home / "auth.json"
+    source_root = Path(os.environ.get("CODEX_HOME", "~/.codex")).expanduser()
+    if source_root.resolve() == codex_home.resolve():
+        return
+    source_auth = source_root / "auth.json"
+    if auth_path.exists():
+        if auth_path.is_symlink() and auth_path.resolve() == source_auth.resolve():
+            return
+        log_event(
+            logger,
+            __import__("logging").INFO,
+            f"{event_prefix}.codex_home.seed.skipped",
+            reason="auth_exists",
+            source=str(source_root),
+            target=str(codex_home),
+        )
+        return
+    if not source_root.exists():
+        log_event(
+            logger,
+            __import__("logging").WARNING,
+            f"{event_prefix}.codex_home.seed.skipped",
+            reason="source_missing",
+            source=str(source_root),
+            target=str(codex_home),
+        )
+        return
+    if not source_auth.exists():
+        log_event(
+            logger,
+            __import__("logging").WARNING,
+            f"{event_prefix}.codex_home.seed.skipped",
+            reason="auth_missing",
+            source=str(source_root),
+            target=str(codex_home),
+        )
+        return
+    try:
+        auth_path.symlink_to(source_auth)
+        log_event(
+            logger,
+            __import__("logging").INFO,
+            f"{event_prefix}.codex_home.seeded",
+            source=str(source_root),
+            target=str(codex_home),
+        )
+    except OSError as exc:
+        log_event(
+            logger,
+            __import__("logging").WARNING,
+            f"{event_prefix}.codex_home.seed.failed",
+            exc=exc,
+            source=str(source_root),
+            target=str(codex_home),
+        )
+
+
+def build_app_server_env(
+    command: Sequence[str],
+    workspace_root: Path,
+    state_dir: Path,
+    *,
+    logger: Any = None,
+    event_prefix: str = "app_server",
+    base_env: Optional[dict[str, str]] = None,
+) -> dict[str, str]:
+    env = app_server_env(command, workspace_root, base_env=base_env)
+    codex_home = state_dir / "codex_home"
+    codex_home.mkdir(parents=True, exist_ok=True)
+    seed_codex_home(codex_home, logger=logger, event_prefix=event_prefix)
+    env["CODEX_HOME"] = str(codex_home)
+    return env
+
+
+def _extract_turn_id(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for key in ("turnId", "turn_id", "id"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    turn = payload.get("turn")
+    if isinstance(turn, dict):
+        for key in ("id", "turnId", "turn_id"):
+            value = turn.get(key)
+            if isinstance(value, str):
+                return value
+    return None
+
+
+def _extract_thread_id_from_container(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for key in ("threadId", "thread_id"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    thread = payload.get("thread")
+    if isinstance(thread, dict):
+        for key in ("id", "threadId", "thread_id"):
+            value = thread.get(key)
+            if isinstance(value, str):
+                return value
+    return None
+
+
+def _extract_thread_id_for_turn(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for candidate in (payload, payload.get("turn"), payload.get("item")):
+        thread_id = _extract_thread_id_from_container(candidate)
+        if thread_id:
+            return thread_id
+    return None
+
+
+def _extract_thread_id(payload: Any) -> Optional[str]:
+    if not isinstance(payload, dict):
+        return None
+    for key in ("threadId", "thread_id", "id"):
+        value = payload.get(key)
+        if isinstance(value, str):
+            return value
+    thread = payload.get("thread")
+    if isinstance(thread, dict):
+        for key in ("id", "threadId", "thread_id"):
+            value = thread.get(key)
+            if isinstance(value, str):
+                return value
+    return None