codex-autorunner 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

codex_autorunner/static/utils.js

@@ -542,7 +542,7 @@ export function confirmModal(message, options = {}) {
     });
 }
 export function inputModal(message, options = {}) {
-    const { placeholder = "", defaultValue = "", confirmText = "OK", cancelText = "Cancel" } = options;
+    const { placeholder = "", defaultValue = "", confirmText = "OK", cancelText = "Cancel", allowEmpty = false, } = options;
     return new Promise((resolve) => {
         const overlay = document.getElementById("input-modal");
         const messageEl = document.getElementById("input-modal-message");
@@ -576,6 +576,10 @@ export function inputModal(message, options = {}) {
         };
         const onOk = () => {
             const value = inputEl.value.trim();
+            if (allowEmpty) {
+                finalize(value);
+                return;
+            }
             finalize(value || null);
         };
         const onCancel = () => {

codex_autorunner/surfaces/cli/cli.py

@@ -38,7 +38,6 @@ from ...core.flows.worker_process import (
 )
 from ...core.git_utils import GitError, run_git
 from ...core.hub import HubSupervisor
-from ...core.locks import file_lock
 from ...core.logging_utils import log_event, setup_rotating_logger
 from ...core.optional_dependencies import require_optional_dependencies
 from ...core.runtime import (
@@ -106,11 +105,13 @@ from ...tickets.lint import (
 from ...voice import VoiceConfig
 from ..web.app import create_hub_app
 from .pma_cli import pma_app as pma_cli_app
+from .template_repos import TemplatesConfigError, load_template_repos_manager
 
 logger = logging.getLogger("codex_autorunner.cli")
 
 app = typer.Typer(add_completion=False)
 hub_app = typer.Typer(add_completion=False)
+dispatch_app = typer.Typer(add_completion=False)
 telegram_app = typer.Typer(add_completion=False)
 templates_app = typer.Typer(add_completion=False)
 repos_app = typer.Typer(add_completion=False)
@@ -155,26 +156,6 @@ def _require_hub_config(path: Optional[Path]) -> HubConfig:
         _raise_exit(str(exc), cause=exc)
 
 
-def _load_hub_config_yaml(path: Path) -> dict:
-    if not path.exists():
-        _raise_exit(f"Hub config file not found: {path}")
-    try:
-        data = yaml.safe_load(path.read_text(encoding="utf-8"))
-        if not isinstance(data, dict):
-            _raise_exit(f"Hub config must be a YAML mapping: {path}")
-        return data
-    except yaml.YAMLError as exc:
-        _raise_exit(f"Invalid YAML in hub config: {exc}", cause=exc)
-    except OSError as exc:
-        _raise_exit(f"Failed to read hub config: {exc}", cause=exc)
-
-
-def _write_hub_config_yaml(path: Path, data: dict) -> None:
-    lock_path = path.parent / (path.name + ".lock")
-    with file_lock(lock_path):
-        path.write_text(yaml.safe_dump(data, sort_keys=False), encoding="utf-8")
-
-
 def _require_templates_enabled(config: RepoConfig) -> None:
     if not config.templates.enabled:
         _raise_exit(
@@ -452,6 +433,31 @@ def _request_json(
     return data if isinstance(data, dict) else {}
 
 
+def _request_form_json(
+    method: str,
+    url: str,
+    form: Optional[dict] = None,
+    token_env: Optional[str] = None,
+    *,
+    force_multipart: bool = False,
+) -> dict:
+    headers = None
+    if token_env:
+        token = _require_auth_token(token_env)
+        headers = {"Authorization": f"Bearer {token}"}
+    data = form
+    files = None
+    if force_multipart:
+        data = form or {}
+        files = []
+    response = httpx.request(
+        method, url, data=data, files=files, timeout=5.0, headers=headers
+    )
+    response.raise_for_status()
+    data = response.json()
+    return data if isinstance(data, dict) else {}
+
+
 def _require_optional_feature(
     *, feature: str, deps: list[tuple[str, str]], extra: Optional[str] = None
 ) -> None:
@@ -462,6 +468,7 @@ def _require_optional_feature(
 
 
 app.add_typer(hub_app, name="hub")
+hub_app.add_typer(dispatch_app, name="dispatch")
 hub_app.add_typer(worktree_app, name="worktree")
 app.add_typer(telegram_app, name="telegram")
 app.add_typer(templates_app, name="templates")
@@ -780,16 +787,8 @@ def repos_list(
     output_json: bool = typer.Option(False, "--json", help="Emit JSON output"),
 ):
     """List configured template repos."""
-    config = _require_hub_config(hub)
-    hub_config_path = config.root / CONFIG_FILENAME
-    data = _load_hub_config_yaml(hub_config_path)
-
-    templates_config = data.get("templates", {})
-    if not isinstance(templates_config, dict):
-        templates_config = {}
-    repos = templates_config.get("repos", [])
-    if not isinstance(repos, list):
-        repos = []
+    manager = load_template_repos_manager(hub)
+    repos = manager.list_repos()
 
     if output_json:
         payload = {"repos": repos}
@@ -823,43 +822,16 @@ def repos_add(
     hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
 ):
     """Add a template repo to the hub config."""
-    config = _require_hub_config(hub)
-    hub_config_path = config.root / CONFIG_FILENAME
-    data = _load_hub_config_yaml(hub_config_path)
-
-    templates_config = data.get("templates", {})
-    if not isinstance(templates_config, dict):
-        templates_config = {}
-    enabled = templates_config.get("enabled", True)
-    if enabled is False:
-        _raise_exit(
-            "Templates are disabled. Set templates.enabled=true in the hub config to enable."
-        )
-
-    templates_config = data.setdefault("templates", {})
-    if not isinstance(templates_config, dict):
-        _raise_exit("Invalid templates config in hub config")
-    templates_config.setdefault("enabled", True)
-    repos = templates_config.setdefault("repos", [])
-    if not isinstance(repos, list):
-        _raise_exit("Invalid repos config in hub config")
-
-    existing_ids = {repo.get("id") for repo in repos if isinstance(repo, dict)}
-    if repo_id in existing_ids:
-        _raise_exit(f"Repo ID '{repo_id}' already exists. Use a unique ID.")
-
-    new_repo = {
-        "id": repo_id,
-        "url": url,
-        "default_ref": default_ref,
-    }
-    if trusted is not None:
-        new_repo["trusted"] = trusted
-
-    repos.append(new_repo)
+    manager = load_template_repos_manager(hub)
+    try:
+        manager.add_repo(repo_id, url, trusted, default_ref)
+    except TemplatesConfigError as exc:
+        _raise_exit(str(exc), cause=exc)
+    except OSError as exc:
+        _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
     try:
-        _write_hub_config_yaml(hub_config_path, data)
+        manager.save()
     except OSError as exc:
         _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
@@ -872,29 +844,16 @@ def repos_remove(
     hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
 ):
     """Remove a template repo from the hub config."""
-    config = _require_hub_config(hub)
-    hub_config_path = config.root / CONFIG_FILENAME
-    data = _load_hub_config_yaml(hub_config_path)
-
-    templates_config = data.get("templates", {})
-    if not isinstance(templates_config, dict):
-        templates_config = {}
-    repos = templates_config.get("repos", [])
-    if not isinstance(repos, list):
-        repos = []
-
-    original_count = len(repos)
-    filtered_repos = [
-        repo for repo in repos if isinstance(repo, dict) and repo.get("id") != repo_id
-    ]
-
-    if len(filtered_repos) == original_count:
-        _raise_exit(f"Repo ID '{repo_id}' not found in config.")
-
-    templates_config["repos"] = filtered_repos
+    manager = load_template_repos_manager(hub)
+    try:
+        manager.remove_repo(repo_id)
+    except TemplatesConfigError as exc:
+        _raise_exit(str(exc), cause=exc)
+    except OSError as exc:
+        _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
     try:
-        _write_hub_config_yaml(hub_config_path, data)
+        manager.save()
     except OSError as exc:
         _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
@@ -907,29 +866,16 @@ def repos_trust(
     hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
 ):
     """Mark a template repo as trusted (skip scanning)."""
-    config = _require_hub_config(hub)
-    hub_config_path = config.root / CONFIG_FILENAME
-    data = _load_hub_config_yaml(hub_config_path)
-
-    templates_config = data.get("templates", {})
-    if not isinstance(templates_config, dict):
-        templates_config = {}
-    repos = templates_config.get("repos", [])
-    if not isinstance(repos, list):
-        repos = []
-
-    found = False
-    for repo in repos:
-        if isinstance(repo, dict) and repo.get("id") == repo_id:
-            repo["trusted"] = True
-            found = True
-            break
-
-    if not found:
-        _raise_exit(f"Repo ID '{repo_id}' not found in config.")
+    manager = load_template_repos_manager(hub)
+    try:
+        manager.set_trusted(repo_id, True)
+    except TemplatesConfigError as exc:
+        _raise_exit(str(exc), cause=exc)
+    except OSError as exc:
+        _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
     try:
-        _write_hub_config_yaml(hub_config_path, data)
+        manager.save()
     except OSError as exc:
         _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
@@ -942,29 +888,16 @@ def repos_untrust(
     hub: Optional[Path] = typer.Option(None, "--hub", help="Hub root path"),
 ):
     """Mark a template repo as untrusted (require scanning)."""
-    config = _require_hub_config(hub)
-    hub_config_path = config.root / CONFIG_FILENAME
-    data = _load_hub_config_yaml(hub_config_path)
-
-    templates_config = data.get("templates", {})
-    if not isinstance(templates_config, dict):
-        templates_config = {}
-    repos = templates_config.get("repos", [])
-    if not isinstance(repos, list):
-        repos = []
-
-    found = False
-    for repo in repos:
-        if isinstance(repo, dict) and repo.get("id") == repo_id:
-            repo["trusted"] = False
-            found = True
-            break
-
-    if not found:
-        _raise_exit(f"Repo ID '{repo_id}' not found in config.")
+    manager = load_template_repos_manager(hub)
+    try:
+        manager.set_trusted(repo_id, False)
+    except TemplatesConfigError as exc:
+        _raise_exit(str(exc), cause=exc)
+    except OSError as exc:
+        _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
     try:
-        _write_hub_config_yaml(hub_config_path, data)
+        manager.save()
     except OSError as exc:
         _raise_exit(f"Failed to write hub config: {exc}", cause=exc)
 
@@ -1783,6 +1716,150 @@ def hub_snapshot(
     typer.echo(json.dumps(snapshot, indent=indent))
 
 
+@dispatch_app.command("reply")
+def hub_dispatch_reply(
+    repo_id: str = typer.Option(..., "--repo-id", help="Hub repo id"),
+    run_id: str = typer.Option(..., "--run-id", help="Flow run id (UUID)"),
+    message: Optional[str] = typer.Option(None, "--message", help="Reply message body"),
+    message_file: Optional[Path] = typer.Option(
+        None, "--message-file", help="Read reply message body from file"
+    ),
+    resume: bool = typer.Option(
+        True, "--resume/--no-resume", help="Resume run after posting reply"
+    ),
+    idempotency_key: Optional[str] = typer.Option(
+        None, "--idempotency-key", help="Optional key to avoid duplicate replies"
+    ),
+    path: Optional[Path] = typer.Option(None, "--path", "--hub", help="Hub root path"),
+    output_json: bool = typer.Option(
+        True, "--json/--no-json", help="Emit JSON output (default: true)"
+    ),
+    pretty: bool = typer.Option(False, "--pretty", help="Pretty-print JSON output"),
+):
+    """Reply to a paused dispatch and optionally resume the run."""
+    config = _require_hub_config(path)
+
+    if bool(message) == bool(message_file):
+        _raise_exit("Provide exactly one of --message or --message-file.")
+
+    raw_message = message
+    if message_file is not None:
+        try:
+            raw_message = message_file.read_text(encoding="utf-8")
+        except OSError as exc:
+            _raise_exit(f"Failed to read message file: {exc}", cause=exc)
+    body = (raw_message or "").strip()
+    if not body:
+        _raise_exit("Reply message cannot be empty.")
+
+    thread_url = _build_server_url(
+        config, f"/repos/{repo_id}/api/messages/threads/{run_id}"
+    )
+    reply_url = _build_server_url(
+        config, f"/repos/{repo_id}/api/messages/{run_id}/reply"
+    )
+    resume_url = _build_server_url(
+        config, f"/repos/{repo_id}/api/flows/{run_id}/resume"
+    )
+
+    marker = None
+    if idempotency_key:
+        marker = f"<!-- car-idempotency-key:{idempotency_key.strip()} -->"
+
+    try:
+        thread = _request_json(
+            "GET", thread_url, token_env=config.server_auth_token_env
+        )
+    except (
+        httpx.HTTPError,
+        httpx.ConnectError,
+        httpx.TimeoutException,
+        OSError,
+    ) as exc:
+        _raise_exit(
+            "Failed to query run thread via hub server. Ensure 'car hub serve' is running.",
+            cause=exc,
+        )
+
+    run_status = ((thread.get("run") or {}) if isinstance(thread, dict) else {}).get(
+        "status"
+    )
+    if run_status != "paused":
+        _raise_exit(
+            f"Run {run_id} is not paused-awaiting-input (status={run_status or 'unknown'})."
+        )
+
+    duplicate = False
+    reply_seq = None
+    if marker:
+        replies = thread.get("reply_history", []) if isinstance(thread, dict) else []
+        for entry in replies if isinstance(replies, list) else []:
+            reply = entry.get("reply") if isinstance(entry, dict) else None
+            existing_body = (reply.get("body") or "") if isinstance(reply, dict) else ""
+            if marker in existing_body:
+                duplicate = True
+                reply_seq = entry.get("seq") if isinstance(entry, dict) else None
+                break
+
+    if not duplicate:
+        post_body = body
+        if marker:
+            post_body = f"{body}\n\n{marker}"
+        try:
+            reply_resp = _request_form_json(
+                "POST",
+                reply_url,
+                form={"body": post_body},
+                token_env=config.server_auth_token_env,
+                force_multipart=True,
+            )
+            reply_seq = reply_resp.get("seq")
+        except (
+            httpx.HTTPError,
+            httpx.ConnectError,
+            httpx.TimeoutException,
+            OSError,
+        ) as exc:
+            _raise_exit("Failed to post dispatch reply.", cause=exc)
+
+    resumed = False
+    resume_status = None
+    if resume:
+        try:
+            resume_resp = _request_json(
+                "POST", resume_url, payload={}, token_env=config.server_auth_token_env
+            )
+            resumed = True
+            resume_status = resume_resp.get("status")
+        except (
+            httpx.HTTPError,
+            httpx.ConnectError,
+            httpx.TimeoutException,
+            OSError,
+        ) as exc:
+            _raise_exit("Reply posted but resume failed.", cause=exc)
+
+    payload = {
+        "repo_id": repo_id,
+        "run_id": run_id,
+        "reply_seq": reply_seq,
+        "duplicate": duplicate,
+        "resumed": resumed,
+        "resume_status": resume_status,
+    }
+
+    if output_json:
+        typer.echo(json.dumps(payload, indent=2 if pretty else None))
+        return
+
+    typer.echo(
+        f"Reply {'reused' if duplicate else 'posted'} for run {run_id}"
+        + (f" (seq={reply_seq})" if reply_seq else "")
+    )
+    if resume:
+        typer.echo(f"Run resumed: status={resume_status or 'unknown'}")
+
+
 @telegram_app.command("start")
 def telegram_start(
     path: Optional[Path] = typer.Option(None, "--path", help="Repo or hub root path"),

codex_autorunner/surfaces/cli/template_repos.py

@@ -0,0 +1,157 @@
+"""Template repo config manager to centralize repo-config mutations."""
+
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+import yaml
+
+from ...core.config import CONFIG_FILENAME, load_hub_config
+from ...core.locks import file_lock
+
+
+class TemplatesConfigError(Exception):
+    """Error in templates configuration."""
+
+
+class TemplateReposManager:
+    """Manager for template repos in hub config."""
+
+    def __init__(self, hub_config_path: Path) -> None:
+        """Initialize the manager with a hub config path."""
+        self.hub_config_path = hub_config_path
+        self._data: dict[str, Any] = {}
+        self._load()
+
+    def _load(self) -> None:
+        """Load the hub config YAML."""
+        if not self.hub_config_path.exists():
+            raise TemplatesConfigError(
+                f"Hub config file not found: {self.hub_config_path}"
+            )
+        try:
+            data = yaml.safe_load(self.hub_config_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                raise TemplatesConfigError(
+                    f"Hub config must be a YAML mapping: {self.hub_config_path}"
+                )
+            self._data = data
+        except yaml.YAMLError as exc:
+            raise TemplatesConfigError(f"Invalid YAML in hub config: {exc}") from exc
+        except OSError as exc:
+            raise TemplatesConfigError(f"Failed to read hub config: {exc}") from exc
+
+    def save(self) -> None:
+        """Save the hub config YAML."""
+        lock_path = self.hub_config_path.parent / (self.hub_config_path.name + ".lock")
+        with file_lock(lock_path):
+            self.hub_config_path.write_text(
+                yaml.safe_dump(self._data, sort_keys=False), encoding="utf-8"
+            )
+
+    def list_repos(self) -> list[dict[str, Any]]:
+        """List all configured template repos."""
+        templates_config = self._data.get("templates", {})
+        if not isinstance(templates_config, dict):
+            templates_config = {}
+        repos = templates_config.get("repos", [])
+        if not isinstance(repos, list):
+            repos = []
+        return repos
+
+    def add_repo(
+        self,
+        repo_id: str,
+        url: str,
+        trusted: Optional[bool] = None,
+        default_ref: str = "main",
+    ) -> None:
+        """Add a template repo."""
+        self._require_templates_enabled()
+
+        templates_config = self._data.setdefault("templates", {})
+        if not isinstance(templates_config, dict):
+            raise TemplatesConfigError("Invalid templates config in hub config")
+        templates_config.setdefault("enabled", True)
+
+        repos = templates_config.setdefault("repos", [])
+        if not isinstance(repos, list):
+            raise TemplatesConfigError("Invalid repos config in hub config")
+
+        existing_ids = {repo.get("id") for repo in repos if isinstance(repo, dict)}
+        if repo_id in existing_ids:
+            raise TemplatesConfigError(
+                f"Repo ID '{repo_id}' already exists. Use a unique ID."
+            )
+
+        new_repo = {
+            "id": repo_id,
+            "url": url,
+            "default_ref": default_ref,
+        }
+        if trusted is not None:
+            new_repo["trusted"] = trusted
+
+        repos.append(new_repo)
+
+    def remove_repo(self, repo_id: str) -> None:
+        """Remove a template repo."""
+        templates_config = self._data.get("templates", {})
+        if not isinstance(templates_config, dict):
+            templates_config = {}
+        repos = templates_config.get("repos", [])
+        if not isinstance(repos, list):
+            repos = []
+
+        original_count = len(repos)
+        filtered_repos = [
+            repo
+            for repo in repos
+            if isinstance(repo, dict) and repo.get("id") != repo_id
+        ]
+
+        if len(filtered_repos) == original_count:
+            raise TemplatesConfigError(f"Repo ID '{repo_id}' not found in config.")
+
+        templates_config["repos"] = filtered_repos
+
+    def set_trusted(self, repo_id: str, trusted: bool) -> None:
+        """Set the trusted status of a template repo."""
+        templates_config = self._data.get("templates", {})
+        if not isinstance(templates_config, dict):
+            templates_config = {}
+        repos = templates_config.get("repos", [])
+        if not isinstance(repos, list):
+            repos = []
+
+        found = False
+        for repo in repos:
+            if isinstance(repo, dict) and repo.get("id") == repo_id:
+                repo["trusted"] = trusted
+                found = True
+                break
+
+        if not found:
+            raise TemplatesConfigError(f"Repo ID '{repo_id}' not found in config.")
+
+    def _require_templates_enabled(self) -> None:
+        """Ensure templates are enabled in config."""
+        templates_config = self._data.get("templates", {})
+        if not isinstance(templates_config, dict):
+            templates_config = {}
+        enabled = templates_config.get("enabled", True)
+        if enabled is False:
+            raise TemplatesConfigError(
+                "Templates are disabled. Set templates.enabled=true in the hub config to enable."
+            )
+
+
+def load_template_repos_manager(hub: Optional[Path]) -> TemplateReposManager:
+    """Load a TemplateReposManager for the given hub path."""
+    try:
+        config = load_hub_config(hub or Path.cwd())
+    except Exception as exc:
+        typer.echo(str(exc), err=True)
+        raise typer.Exit(code=1) from None
+    hub_config_path = config.root / CONFIG_FILENAME
+    return TemplateReposManager(hub_config_path)