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

codex_autorunner/web/schemas.py

@@ -4,7 +4,7 @@ Pydantic request/response schemas for web and API routes.
 
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional
 
 from pydantic import AliasChoices, BaseModel, ConfigDict, Field
 
@@ -13,6 +13,65 @@ class Payload(BaseModel):
     model_config = ConfigDict(extra="ignore", populate_by_name=True)
 
 
+class ResponseModel(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+
+class WorkspaceWriteRequest(Payload):
+    content: str = ""
+
+
+class WorkspaceResponse(ResponseModel):
+    active_context: str
+    decisions: str
+    spec: str
+
+
+class WorkspaceFileItem(ResponseModel):
+    name: str
+    path: str
+    is_pinned: bool = False
+    modified_at: Optional[str] = None
+
+
+class WorkspaceFileListResponse(ResponseModel):
+    files: List[WorkspaceFileItem]
+
+
+class WorkspaceNode(ResponseModel):
+    name: str
+    path: str
+    type: Literal["file", "folder"]
+    is_pinned: bool = False
+    modified_at: Optional[str] = None
+    size: Optional[int] = None
+    children: Optional[List["WorkspaceNode"]] = None
+
+
+WorkspaceNode.model_rebuild()
+
+
+class WorkspaceTreeResponse(ResponseModel):
+    tree: List[WorkspaceNode]
+
+
+class WorkspaceUploadedItem(ResponseModel):
+    filename: str
+    path: str
+    size: int
+
+
+class WorkspaceUploadResponse(ResponseModel):
+    status: str
+    uploaded: List[WorkspaceUploadedItem]
+
+
+class SpecIngestTicketsResponse(ResponseModel):
+    status: str
+    created: int
+    first_ticket_path: Optional[str] = None
+
+
 class RunControlRequest(Payload):
     once: bool = False
     agent: Optional[str] = None
@@ -60,37 +119,6 @@ class HubCleanupWorktreeRequest(Payload):
     delete_remote: bool = False
 
 
-class DocContentRequest(Payload):
-    content: str = ""
-
-
-class SnapshotRequest(Payload):
-    pass
-
-
-class DocChatPayload(Payload):
-    message: Optional[str] = None
-    stream: bool = False
-    targets: Optional[List[str]] = None
-    target: Optional[str] = None
-    agent: Optional[str] = None
-    model: Optional[str] = None
-    reasoning: Optional[str] = None
-    context_doc: Optional[str] = Field(
-        default=None,
-        validation_alias=AliasChoices("context_doc", "contextDoc", "viewing"),
-    )
-
-
-class IngestSpecRequest(Payload):
-    force: bool = False
-    spec_path: Optional[str] = None
-    message: Optional[str] = None
-    agent: Optional[str] = None
-    model: Optional[str] = None
-    reasoning: Optional[str] = None
-
-
 class AppServerThreadResetRequest(Payload):
     key: str = Field(
         validation_alias=AliasChoices("key", "feature", "feature_key", "featureKey")
@@ -125,39 +153,6 @@ class GithubPrSyncRequest(Payload):
     mode: Optional[str] = None
 
 
-class GithubPrFlowStartRequest(Payload):
-    mode: Optional[str] = "issue"
-    issue: Optional[str] = None
-    pr: Optional[str] = None
-    draft: Optional[bool] = None
-    base_branch: Optional[str] = Field(
-        default=None, validation_alias=AliasChoices("base_branch", "baseBranch", "base")
-    )
-    stop_condition: Optional[str] = Field(
-        default=None,
-        validation_alias=AliasChoices("stop_condition", "stopCondition", "until"),
-    )
-    max_cycles: Optional[int] = Field(
-        default=None, validation_alias=AliasChoices("max_cycles", "maxCycles")
-    )
-    max_implementation_runs: Optional[int] = Field(
-        default=None,
-        validation_alias=AliasChoices(
-            "max_implementation_runs", "maxImplementationRuns"
-        ),
-    )
-    max_wallclock_seconds: Optional[int] = Field(
-        default=None,
-        validation_alias=AliasChoices(
-            "max_wallclock_seconds", "maxWallclockSeconds", "timeout_seconds"
-        ),
-    )
-
-
-class GithubPrFlowActionRequest(Payload):
-    pass
-
-
 class SessionStopRequest(Payload):
     session_id: Optional[str] = None
     repo_path: Optional[str] = None
@@ -167,10 +162,6 @@ class SystemUpdateRequest(Payload):
     target: Optional[str] = None
 
 
-class ResponseModel(BaseModel):
-    model_config = ConfigDict(extra="ignore")
-
-
 class HubJobResponse(ResponseModel):
     job_id: str
     kind: str
@@ -248,30 +239,9 @@ class SessionStopResponse(ResponseModel):
     session_id: str
 
 
-class DocsResponse(ResponseModel):
-    todo: str
-    progress: str
-    opinions: str
-    spec: str
-    summary: str
-
-
-class IngestSpecResponse(ResponseModel):
-    status: str
-    todo: str
-    progress: str
-    opinions: str
-    spec: str
-    summary: str
-    patch: Optional[str] = None
-    agent_message: Optional[str] = None
-
-
 class AppServerThreadsResponse(ResponseModel):
-    doc_chat: Dict[str, Optional[str]]
-    doc_chat_opencode: Optional[Dict[str, Optional[str]]] = None
-    spec_ingest: Optional[str] = None
-    spec_ingest_opencode: Optional[str] = None
+    file_chat: Optional[str] = None
+    file_chat_opencode: Optional[str] = None
     autorunner: Optional[str] = None
     autorunner_opencode: Optional[str] = None
     corruption: Optional[Dict[str, Any]] = None
@@ -294,23 +264,6 @@ class AppServerThreadResetAllResponse(ResponseModel):
     cleared: bool
 
 
-class DocWriteResponse(ResponseModel):
-    kind: str
-    content: str
-
-
-class SnapshotResponse(ResponseModel):
-    exists: bool
-    content: str
-    state: Dict[str, Any]
-
-
-class SnapshotCreateResponse(ResponseModel):
-    content: str
-    truncated: bool
-    state: Dict[str, Any]
-
-
 class TokenTotalsResponse(ResponseModel):
     input_tokens: int
     cached_input_tokens: int
@@ -395,3 +348,30 @@ class ReviewStatusResponse(ResponseModel):
 class ReviewControlResponse(ResponseModel):
     status: str
     detail: Optional[str] = None
+
+
+# Ticket CRUD schemas
+
+
+class TicketCreateRequest(Payload):
+    agent: str = "codex"
+    title: Optional[str] = None
+    goal: Optional[str] = None
+    body: str = ""
+
+
+class TicketUpdateRequest(Payload):
+    content: str  # Full markdown with frontmatter
+
+
+class TicketResponse(ResponseModel):
+    path: str
+    index: int
+    frontmatter: Dict[str, Any]
+    body: str
+
+
+class TicketDeleteResponse(ResponseModel):
+    status: str
+    index: int
+    path: str

codex_autorunner/web/static_assets.py

@@ -6,36 +6,14 @@ import os
 import shutil
 import time
 from contextlib import ExitStack
-from importlib import resources
 from pathlib import Path
 from typing import Iterable, Optional
 from uuid import uuid4
 
 from ..core.logging_utils import safe_log
+from ..core.static_assets import missing_static_assets, resolve_static_dir
 
 _ASSET_VERSION_TOKEN = "__CAR_ASSET_VERSION__"
-_REQUIRED_STATIC_ASSETS = (
-    "index.html",
-    "styles.css",
-    "bootstrap.js",
-    "loader.js",
-    "app.js",
-    "github.js",
-    "vendor/xterm.js",
-    "vendor/xterm-addon-fit.js",
-    "vendor/xterm.css",
-)
-
-
-def missing_static_assets(static_dir: Path) -> list[str]:
-    missing: list[str] = []
-    for rel_path in _REQUIRED_STATIC_ASSETS:
-        try:
-            if not (static_dir / rel_path).exists():
-                missing.append(rel_path)
-        except OSError:
-            missing.append(rel_path)
-    return missing
 
 
 def _iter_static_source_files(source_dir: Path) -> Iterable[Path]:
@@ -177,27 +155,6 @@ def index_response_headers() -> dict[str, str]:
     return headers
 
 
-def resolve_static_dir() -> tuple[Path, Optional[ExitStack]]:
-    static_root = resources.files("codex_autorunner").joinpath("static")
-    if isinstance(static_root, Path):
-        if static_root.exists():
-            return static_root, None
-        fallback = Path(__file__).resolve().parent.parent / "static"
-        return fallback, None
-    stack = ExitStack()
-    try:
-        static_path = stack.enter_context(resources.as_file(static_root))
-    except Exception:
-        stack.close()
-        fallback = Path(__file__).resolve().parent.parent / "static"
-        return fallback, None
-    if static_path.exists():
-        return static_path, stack
-    stack.close()
-    fallback = Path(__file__).resolve().parent.parent / "static"
-    return fallback, None
-
-
 def _cleanup_temp_dir(path: Path, logger: logging.Logger) -> None:
     try:
         shutil.rmtree(path)

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