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

codex_autorunner/web/static_refresh.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+from ..core.logging_utils import safe_log
+from .static_assets import (
+    asset_version,
+    materialize_static_assets,
+    missing_static_assets,
+    require_static_assets,
+)
+
+
+def _update_static_files(static_files: object, static_dir: Path) -> None:
+    try:
+        static_files.directory = static_dir
+        static_files.all_directories = static_files.get_directories(  # type: ignore[attr-defined]
+            static_dir,
+            static_files.packages,  # type: ignore[attr-defined]
+        )
+        static_files.config_checked = False
+    except Exception:
+        return
+
+
+def refresh_static_assets(app: object) -> bool:
+    lock = getattr(getattr(app, "state", None), "static_assets_lock", None)
+    if lock is None or not lock.acquire(blocking=False):
+        return False
+    try:
+        state = getattr(app, "state", None)
+        if state is None:
+            return False
+        current_dir = getattr(state, "static_dir", None)
+        if isinstance(current_dir, Path) and not missing_static_assets(current_dir):
+            return True
+        config = getattr(state, "config", None)
+        logger = getattr(state, "logger", None)
+        static_candidates = []
+        if config is not None:
+            static_candidates.append(config.static_assets)
+        hub_static = getattr(state, "hub_static_assets", None)
+        if hub_static is not None and (
+            not static_candidates
+            or hub_static.cache_root != static_candidates[0].cache_root
+        ):
+            static_candidates.append(hub_static)
+        for static_cfg in static_candidates:
+            try:
+                static_dir, static_context = materialize_static_assets(
+                    static_cfg.cache_root,
+                    max_cache_entries=static_cfg.max_cache_entries,
+                    max_cache_age_days=static_cfg.max_cache_age_days,
+                    logger=logger,
+                )
+                require_static_assets(static_dir, logger)
+            except Exception as exc:
+                if logger is not None:
+                    safe_log(
+                        logger,
+                        logging.WARNING,
+                        "Static assets refresh failed for cache root %s",
+                        static_cfg.cache_root,
+                        exc=exc,
+                    )
+                continue
+            old_context: Optional[object] = getattr(
+                state, "static_assets_context", None
+            )
+            if old_context is not None:
+                try:
+                    old_context.close()
+                except Exception:
+                    pass
+            state.static_dir = static_dir
+            state.static_assets_context = static_context
+            state.asset_version = asset_version(static_dir)
+            static_files = getattr(state, "static_files", None)
+            if static_files is not None:
+                _update_static_files(static_files, static_dir)
+            return True
+        return False
+    finally:
+        lock.release()

codex_autorunner/workspace/__init__.py

@@ -0,0 +1,40 @@
+"""Workspace docs helpers (active context, decisions, spec).
+
+Workspace docs are optional and live under `.codex-autorunner/workspace/`.
+They are distinct from tickets, which live under `.codex-autorunner/tickets/`.
+"""
+
+import hashlib
+from pathlib import Path
+
+from ..core.utils import canonicalize_path
+from .paths import (
+    WORKSPACE_DOC_KINDS,
+    WorkspaceDocKind,
+    read_workspace_doc,
+    workspace_doc_path,
+    write_workspace_doc,
+)
+
+WORKSPACE_ID_HEX_LEN = 12
+
+
+def canonical_workspace_root(path: Path) -> Path:
+    return canonicalize_path(path)
+
+
+def workspace_id_for_path(path: Path) -> str:
+    canonical = canonical_workspace_root(path)
+    digest = hashlib.sha256(str(canonical).encode("utf-8")).hexdigest()
+    return digest[:WORKSPACE_ID_HEX_LEN]
+
+
+__all__ = [
+    "WORKSPACE_DOC_KINDS",
+    "WorkspaceDocKind",
+    "workspace_doc_path",
+    "read_workspace_doc",
+    "write_workspace_doc",
+    "canonical_workspace_root",
+    "workspace_id_for_path",
+]

codex_autorunner/workspace/paths.py

@@ -0,0 +1,319 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path, PurePosixPath
+from typing import Literal, cast
+
+from ..core import drafts as draft_utils
+
+WorkspaceDocKind = Literal["active_context", "decisions", "spec"]
+WORKSPACE_DOC_KINDS: tuple[WorkspaceDocKind, ...] = (
+    "active_context",
+    "decisions",
+    "spec",
+)
+
+
+@dataclass
+class WorkspaceFile:
+    name: str
+    path: str  # path relative to the workspace directory (POSIX)
+    is_pinned: bool = False
+    modified_at: str | None = None
+
+
+def _normalize_kind(kind: str) -> WorkspaceDocKind:
+    key = (kind or "").strip().lower()
+    if key not in WORKSPACE_DOC_KINDS:
+        raise ValueError("invalid workspace doc kind")
+    return cast(WorkspaceDocKind, key)
+
+
+def workspace_dir(repo_root: Path) -> Path:
+    return repo_root / ".codex-autorunner" / "workspace"
+
+
+PINNED_DOC_FILENAMES = {f"{kind}.md" for kind in WORKSPACE_DOC_KINDS}
+
+
+@dataclass
+class WorkspaceNode:
+    name: str
+    path: str  # relative to workspace dir
+    type: Literal["file", "folder"]
+    is_pinned: bool = False
+    modified_at: str | None = None
+    size: int | None = None  # files only
+    children: list["WorkspaceNode"] | None = None  # folders only
+
+
+def normalize_workspace_rel_path(repo_root: Path, rel_path: str) -> tuple[Path, str]:
+    """Normalize a user-supplied workspace path and ensure it stays in-tree.
+
+    We accept POSIX-style relative paths only, then resolve the full path and
+    verify the result is still under the workspace directory. This guards
+    against ".." traversal and symlink escapes that CodeQL flagged.
+    """
+
+    base = workspace_dir(repo_root)
+    base_real = os.path.realpath(base)
+    cleaned = (rel_path or "").strip()
+    if not cleaned:
+        raise ValueError("invalid workspace file path")
+
+    relative = PurePosixPath(cleaned)
+    if relative.is_absolute() or ".." in relative.parts:
+        raise ValueError("invalid workspace file path")
+
+    # Normalize the relative path to collapse any sneaky segments
+    norm_relative = os.path.normpath(relative.as_posix())
+    if norm_relative in {".", ""}:
+        normalized = ""
+    else:
+        normalized = norm_relative
+
+    # Reject traversal or absolute inputs after normalization
+    if (
+        normalized.startswith("..")
+        or normalized.startswith("/")
+        or normalized.startswith("\\")
+    ):
+        raise ValueError("invalid workspace file path")
+
+    candidate_str = os.path.realpath(os.path.join(base_real, normalized))
+    # Ensure the resolved path stays under the workspace directory
+    if not (candidate_str == base_real or candidate_str.startswith(base_real + os.sep)):
+        raise ValueError("invalid workspace file path")
+
+    candidate = Path(candidate_str)
+    rel_posix = candidate.relative_to(base_real).as_posix()
+    return candidate, rel_posix
+
+
+def sanitize_workspace_filename(filename: str) -> str:
+    """Return a safe filename for workspace uploads.
+
+    We strip any directory components, collapse whitespace, and guard against
+    empty names. Caller is responsible for applying any per-workspace policy
+    (e.g., overwrite vs. reject).
+    """
+
+    cleaned = (filename or "").strip()
+    # Drop any path fragments that may be embedded in the upload
+    base = PurePosixPath(cleaned).name
+    # Remove remaining separators/backslashes that PurePosixPath.name could keep
+    base = base.replace("/", "").replace("\\", "")
+    if base in {".", ".."}:
+        base = ""
+    # Collapse whitespace to single spaces to keep names readable
+    base = " ".join(base.split())
+    if not base:
+        return "upload"
+    return base
+
+
+def workspace_doc_path(repo_root: Path, kind: str) -> Path:
+    key = _normalize_kind(kind)
+    return workspace_dir(repo_root) / f"{key}.md"
+
+
+def read_workspace_file(
+    repo_root: Path, rel_path: str
+) -> str:  # codeql[py/path-injection]
+    path, _ = normalize_workspace_rel_path(repo_root, rel_path)
+    if (
+        path.is_dir()
+    ):  # codeql[py/path-injection] validated by normalize_workspace_rel_path
+        raise ValueError("path points to a directory")
+    if (
+        not path.exists()
+    ):  # codeql[py/path-injection] validated by normalize_workspace_rel_path
+        return ""
+    return path.read_text(
+        encoding="utf-8"
+    )  # codeql[py/path-injection] validated by normalize_workspace_rel_path
+
+
+def write_workspace_file(  # codeql[py/path-injection]
+    repo_root: Path, rel_path: str, content: str
+) -> str:
+    path, rel_posix = normalize_workspace_rel_path(repo_root, rel_path)
+    if (
+        path.exists() and path.is_dir()
+    ):  # codeql[py/path-injection] validated by normalize_workspace_rel_path
+        raise ValueError("path points to a directory")
+    path.parent.mkdir(
+        parents=True, exist_ok=True
+    )  # codeql[py/path-injection] validated by normalize_workspace_rel_path
+    path.write_text(
+        content or "", encoding="utf-8"
+    )  # codeql[py/path-injection] validated by normalize_workspace_rel_path
+    try:
+        rel = path.relative_to(repo_root).as_posix()
+        draft_utils.invalidate_drafts_for_path(repo_root, rel)
+        state_key = f"workspace_{rel_posix.replace('/', '_')}"
+        draft_utils.remove_draft(repo_root, state_key)
+    except Exception:
+        # best effort; do not block writes
+        pass
+    return path.read_text(encoding="utf-8")
+
+
+def read_workspace_doc(repo_root: Path, kind: str) -> str:
+    path = workspace_doc_path(repo_root, kind)
+    if not path.exists():
+        return ""
+    return path.read_text(encoding="utf-8")
+
+
+def write_workspace_doc(  # codeql[py/path-injection]
+    repo_root: Path, kind: str, content: str
+) -> str:
+    path = workspace_doc_path(repo_root, kind)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        content or "", encoding="utf-8"
+    )  # codeql[py/path-injection] workspace_doc_path is deterministic
+    try:
+        rel = path.relative_to(repo_root).as_posix()
+        draft_utils.invalidate_drafts_for_path(repo_root, rel)
+        state_key = f"workspace_{rel.replace('/', '_')}"
+        draft_utils.remove_draft(repo_root, state_key)
+    except Exception:
+        pass
+    return path.read_text(encoding="utf-8")
+
+
+def _format_mtime(path: Path) -> str | None:
+    if not path.exists():
+        return None
+    ts = datetime.fromtimestamp(path.stat().st_mtime, tz=timezone.utc)
+    return ts.isoformat()
+
+
+def list_workspace_files(
+    repo_root: Path,
+) -> list[WorkspaceFile]:  # codeql[py/path-injection]
+    base = workspace_dir(repo_root)
+    base.mkdir(parents=True, exist_ok=True)
+
+    pinned: list[WorkspaceFile] = []
+    for kind in WORKSPACE_DOC_KINDS:
+        path = workspace_doc_path(repo_root, kind)
+        rel = path.relative_to(base).as_posix()
+        pinned.append(
+            WorkspaceFile(
+                name=path.name,
+                path=rel,
+                is_pinned=True,
+                modified_at=_format_mtime(path),
+            )
+        )
+
+    others: list[WorkspaceFile] = []
+    if base.exists():
+        for file_path in base.rglob("*"):
+            if file_path.is_dir():
+                continue
+            try:
+                rel = file_path.relative_to(base).as_posix()
+            except ValueError:
+                continue
+            if any(rel == pinned_file.path for pinned_file in pinned):
+                continue
+            others.append(
+                WorkspaceFile(
+                    name=file_path.name,
+                    path=rel,
+                    is_pinned=False,
+                    modified_at=_format_mtime(file_path),
+                )
+            )
+
+    others.sort(key=lambda f: f.path)
+    return [*pinned, *others]
+
+
+def _sort_workspace_children(path: Path) -> tuple[int, str]:
+    # Folders first, then files, both alphabetized (case-insensitive)
+    return (0 if path.is_dir() else 1, path.name.lower())
+
+
+def _is_within_workspace(base_real: Path, candidate: Path) -> bool:
+    try:
+        candidate.resolve().relative_to(base_real)
+        return True
+    except Exception:
+        return False
+
+
+def _file_node(base: Path, path: Path, is_pinned: bool = False) -> WorkspaceNode:
+    rel = path.relative_to(base).as_posix()
+    size: int | None = None
+    if path.exists() and path.is_file():
+        try:
+            size = path.stat().st_size
+        except OSError:
+            size = None
+    return WorkspaceNode(
+        name=path.name,
+        path=rel,
+        type="file",
+        is_pinned=is_pinned,
+        modified_at=_format_mtime(path),
+        size=size,
+    )
+
+
+def _build_workspace_tree(base: Path, path: Path) -> WorkspaceNode:
+    is_symlink = path.is_symlink()
+    is_folder = path.is_dir() and not is_symlink
+    is_pinned = path.name in PINNED_DOC_FILENAMES and path.parent == base
+
+    if not is_folder:
+        return _file_node(base, path, is_pinned=is_pinned)
+
+    children: list[WorkspaceNode] = []
+    for child in sorted(path.iterdir(), key=_sort_workspace_children):
+        # Avoid duplicating pinned docs surfaced at the root list
+        if child.parent == base and child.name in PINNED_DOC_FILENAMES:
+            continue
+        # Skip symlink escapes that resolve outside the workspace
+        if child.is_symlink() and not _is_within_workspace(base.resolve(), child):
+            continue
+        children.append(_build_workspace_tree(base, child))
+
+    return WorkspaceNode(
+        name=path.name,
+        path=path.relative_to(base).as_posix(),
+        type="folder",
+        is_pinned=False,
+        modified_at=_format_mtime(path),
+        children=children,
+    )
+
+
+def list_workspace_tree(repo_root: Path) -> list[WorkspaceNode]:
+    """Return hierarchical workspace structure (folders + files)."""
+
+    base = workspace_dir(repo_root)
+    base.mkdir(parents=True, exist_ok=True)
+    base_real = base.resolve()
+
+    nodes: list[WorkspaceNode] = []
+
+    # Pinned docs first (even if missing)
+    for name in sorted(PINNED_DOC_FILENAMES):
+        pinned_path = base / name
+        nodes.append(_file_node(base, pinned_path, is_pinned=True))
+
+    for child in sorted(base.iterdir(), key=_sort_workspace_children):
+        if child.parent == base and child.name in PINNED_DOC_FILENAMES:
+            continue
+        if child.is_symlink() and not _is_within_workspace(base_real, child):
+            continue
+        nodes.append(_build_workspace_tree(base, child))
+
+    return nodes

{codex_autorunner-0.1.1.dist-info → codex_autorunner-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codex-autorunner
-Version: 0.1.1
+Version: 1.0.0
 Summary: Codex autorunner CLI per DESIGN-V1
 Author: Codex
 License: MIT License
@@ -45,10 +45,12 @@ Requires-Dist: ptyprocess>=0.7
 Requires-Dist: python-multipart>=0.0.9
 Requires-Dist: python-dotenv>=1.0
 Requires-Dist: httpx>=0.27
+Requires-Dist: tenacity>=8.0
 Provides-Extra: dev
 Requires-Dist: black==25.11.0; extra == "dev"
 Requires-Dist: mypy>=1.10; extra == "dev"
 Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
 Requires-Dist: pytest-timeout>=2.0; extra == "dev"
 Requires-Dist: ruff>=0.5.0; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
@@ -63,11 +65,17 @@ Dynamic: license-file
 # codex-autorunner
 [![PyPI](https://img.shields.io/pypi/v/codex-autorunner.svg)](https://pypi.org/project/codex-autorunner/)
 
-An opinionated autorunner that uses the Codex CLI to work on large tasks via a simple loop. On each loop we feed the Codex instance the last one's final output along with core documents.
-1. TODO - Tracks long-horizon tasks
-2. PROGRESS - High level overview of what's been done already that may be relevant for future agents
-3. OPINIONS - Guidelines for how we should approach implementation
-4. SPEC - Source-of-truth requirements and scope for large features/projects
+An opinionated autorunner that uses the Codex app-server as the primary execution backend with OpenCode support to work on large tasks via a simple loop. On each loop we feed the Codex instance the last one's final output along with core documents.
+
+In the current model, the primary work surface is **tickets**:
+
+- `.codex-autorunner/tickets/TICKET-###.md`
+
+Optionally, you can maintain lightweight **workspace docs** (auto-created on write; missing is OK):
+
+- `.codex-autorunner/workspace/active_context.md`
+- `.codex-autorunner/workspace/decisions.md`
+- `.codex-autorunner/workspace/spec.md`
 
 ## Sneak Peak
 Run multiple agents on many repositories, with git worktree support
@@ -79,8 +87,7 @@ See the progress of your long running tasks with a high level overview
 Dive deep into specific agent execution with a rich but readable log
 ![Desktop logs](docs/screenshots/car-desktop-logs.png)
 
-All memory and opinions are markdown files! Edit them directly or chat with the document!
-![Desktop TODO](docs/screenshots/car-desktop-todo.png)
+Tickets and workspace docs are markdown files. Edit them directly or use the web UI’s file chat to iterate with the agent.
 
 Use codex CLI directly for multi-shot problem solving or `/review`
 ![Desktop terminal](docs/screenshots/car-desktop-terminal.png)
@@ -90,11 +97,10 @@ Mobile-first experience, code on the go with Whisper support (BYOK)
 
 ## What it does
 - Initializes a repo with Codex-friendly docs and config.
-- Runs Codex in a loop against the repo, streaming logs.
+- Runs Codex app-server in a loop against the repo, streaming logs via OpenCode runtime.
 - Tracks state, logs, and config under `.codex-autorunner/`.
-- Exposes a power-user HTTP API and web UI for docs, logs, runner control, and a Codex TUI terminal.
+- Exposes a power-user HTTP API and web UI for tickets, workspace docs, file chat, logs, runner control, and a Codex TUI terminal.
 - Optionally runs a Telegram bot for interactive, user-in-the-loop Codex sessions.
-- Generates a pasteable repo snapshot (`.codex-autorunner/SNAPSHOT.md`) for sharing with other LLM chats.
 
 CLI commands are available as `codex-autorunner` or the shorter `car`.
 
@@ -164,7 +170,7 @@ If you set a base path, prefix all checks with it.
 
 ## Quick start
 1) Install (editable): `pip install -e .`
-2) Initialize (hub + repo): `codex-autorunner init --git-init` (or `car init --git-init` if you prefer short). This creates the hub config at `.codex-autorunner/config.yml`, plus state/log files and the docs under `.codex-autorunner/`.
+2) Initialize (hub + repo): `codex-autorunner init --git-init` (or `car init --git-init` if you prefer short). This creates the hub config at `.codex-autorunner/config.yml`, plus state/log files and starter content under `.codex-autorunner/` (tickets and optional workspace docs).
 3) Run once: `codex-autorunner once` / `car once`
 4) Continuous loop: `codex-autorunner run` / `car run`
 5) If stuck: `codex-autorunner kill` then `codex-autorunner resume` (or the `car` equivalents)
@@ -229,19 +235,12 @@ If you set `server.auth_token_env`, the API requires `Authorization: Bearer <tok
 - `run` / `once` — run the loop (continuous or single iteration).
 - `resume` — clear stale lock/state and restart; `--once` for a single run.
 - `kill` — SIGTERM the running loop and mark state error.
-- `status` — show current state and outstanding TODO count.
+- `status` — show current state.
 - `sessions` — list terminal sessions (server-backed when available).
 - `stop-session` — stop a terminal session by repo (`--repo`) or id (`--session`).
 - `log` — view logs (tail or specific run).
-- `edit` — open TODO/PROGRESS/OPINIONS/SPEC in `$EDITOR`.
-- `ingest-spec` — generate TODO/PROGRESS/OPINIONS from SPEC using Codex (use `--force` to overwrite).
-- `clear-docs` — reset TODO/PROGRESS/OPINIONS to empty templates (type CLEAR to confirm).
-- `snapshot` — generate/update `.codex-autorunner/SNAPSHOT.md` (incremental by default when one exists; use `--from-scratch` to regenerate).
+- `edit` — open `active_context|decisions|spec` in `$EDITOR`.
 - `serve` — start the HTTP API (FastAPI) on host/port from config (defaults 127.0.0.1:4173).
 
-## Snapshot (repo briefing)
-- Web UI: open the Snapshot tab. If no snapshot exists, you’ll see “Generate snapshot”; otherwise you’ll see “Update snapshot (incremental)” and “Regenerate snapshot (from scratch)”, plus “Copy to clipboard”.
-- CLI: `codex-autorunner snapshot` (or `car snapshot`) writes `.codex-autorunner/SNAPSHOT.md` and `.codex-autorunner/snapshot_state.json`.
-
 ## Star history
 [![Star History Chart](https://api.star-history.com/svg?repos=Git-on-my-level/codex-autorunner&type=Date)](https://star-history.com/#Git-on-my-level/codex-autorunner&Date)