mycode-cli 0.8.6__tar.gz → 0.8.7__tar.gz

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-cli
-Version: 0.8.6
+Version: 0.8.7
 Summary: Minimal coding agent CLI and web UI built on mycode-sdk.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.12
 Requires-Dist: fastapi>=0.115.0
-Requires-Dist: mycode-sdk==0.8.6
+Requires-Dist: mycode-sdk==0.8.7
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=14.2.0

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-cli"
-version = "0.8.6"
+version = "0.8.7"
 description = "Minimal coding agent CLI and web UI built on mycode-sdk."
 requires-python = ">=3.12"
 license = "MIT"
@@ -26,7 +26,7 @@ classifiers = [
 ]
 keywords = ["agent", "cli", "llm", "coding-agent", "fastapi"]
 dependencies = [
-    "mycode-sdk==0.8.6",
+    "mycode-sdk==0.8.7",
     "fastapi>=0.115.0",
     "uvicorn[standard]>=0.32.0",
     "rich>=14.2.0",

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/permissions.py

@@ -73,7 +73,6 @@ def build_permission_hooks(
     settings: Settings,
     *,
     review: ToolReviewCallback | None = None,
-    on_user_denied: Callable[[], None] | None = None,
 ) -> Hooks:
     hooks = Hooks()
     skill_roots = [Path(s.path).parent.resolve(strict=False) for s in discover_skills(settings.cwd)]
@@ -96,8 +95,6 @@ def build_permission_hooks(
             )
             if review_decision == "allow":
                 return None
-            if on_user_denied is not None:
-                on_user_denied()
             return ToolExecutionResult(output=PERMISSION_DENIED_BY_USER_OUTPUT, is_error=True)
 
         return ToolExecutionResult(output=PERMISSION_DENIED_OUTPUT, is_error=True)

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/runtime.py

@@ -28,7 +28,8 @@ def build_agent(
     """
 
     model_config = resolved_provider.model_config
-    agent = Agent(
+    hooks = build_permission_hooks(settings, review=review)
+    return Agent(
         model=resolved_provider.model,
         provider=resolved_provider.provider,
         cwd=cwd,
@@ -46,6 +47,5 @@ def build_agent(
         max_turns=max_turns,
         system=build_system_prompt(cwd, settings),
         tools=DEFAULT_TOOL_SPECS,
+        hooks=hooks,
     )
-    agent.hooks = build_permission_hooks(settings, review=review, on_user_denied=agent.cancel)
-    return agent

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/app.py

@@ -1,6 +1,7 @@
 """FastAPI application entry point."""
 
 import logging
+from collections.abc import Sequence
 from pathlib import Path
 
 from fastapi import FastAPI
@@ -13,6 +14,7 @@ from mycode_cli.server.routers.settings import router as settings_router
 from mycode_cli.server.routers.workspaces import router as workspaces_router
 
 logger = logging.getLogger(__name__)
+DEV_CORS_ORIGINS = ("http://localhost:5173", "http://127.0.0.1:5173")
 
 
 def web_static_path() -> Path:
@@ -21,17 +23,18 @@ def web_static_path() -> Path:
     return Path(__file__).resolve().parent / "static"
 
 
-def create_app(*, serve_web: bool = True) -> FastAPI:
+def create_app(*, serve_web: bool = True, cors_origins: Sequence[str] = ()) -> FastAPI:
     """Create the FastAPI app."""
     logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s: %(message)s")
     application = FastAPI(title="mycode")
 
-    application.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
+    if cors_origins:
+        application.add_middleware(
+            CORSMiddleware,
+            allow_origins=list(cors_origins),
+            allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+            allow_headers=["Content-Type", "Authorization"],
+        )
 
     # Mount API routers
     application.include_router(chat_router, prefix="/api")
@@ -59,7 +62,7 @@ def create_web_app() -> FastAPI:
 
 def create_api_app() -> FastAPI:
     """Create the API-only app."""
-    return create_app(serve_web=False)
+    return create_app(serve_web=False, cors_origins=DEV_CORS_ORIGINS)
 
 
 app = create_app()

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/routers/chat.py

@@ -9,9 +9,10 @@ import os
 from base64 import b64encode
 from collections.abc import AsyncIterator
 from pathlib import Path
-from typing import Any
+from typing import Annotated, Any, cast
 
-from fastapi import APIRouter, HTTPException, Request
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi import Path as PathParam
 from fastapi.responses import StreamingResponse
 
 from mycode.messages import (
@@ -34,7 +35,15 @@ from mycode_cli.permissions import ToolReviewDecision, ToolReviewRequest
 from mycode_cli.runtime import build_agent
 from mycode_cli.server.deps import RunManagerDep, StoreDep
 from mycode_cli.server.run_manager import ActiveRunError, RunManager, RunState
-from mycode_cli.server.schemas import ChatRequest, DecideRequest, StreamEvent
+from mycode_cli.server.schemas import (
+    CancelRunResponse,
+    ChatRequest,
+    ChatResponse,
+    DecideRequest,
+    RunInfo,
+    StatusResponse,
+    StreamEvent,
+)
 
 router = APIRouter()
 
@@ -74,11 +83,11 @@ async def _stream_run(req: Request, state: RunState, after: int) -> AsyncIterato
 
 
 @router.post("/chat")
-async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
+async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep) -> ChatResponse:
     cwd = os.path.abspath(chat.cwd or os.getcwd())
     if not os.path.isdir(cwd):
         raise HTTPException(status_code=400, detail=f"Working directory does not exist: {cwd}")
-    settings = get_settings(cwd)
+    settings = await asyncio.to_thread(get_settings, cwd)
     resolved = resolve_provider(
         settings,
         provider_name=chat.provider,
@@ -92,13 +101,8 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
         raise HTTPException(status_code=400, detail=str(exc)) from exc
     session_id = chat.session_id or "default"
 
-    if chat.message and chat.input:
-        raise HTTPException(status_code=400, detail="message and input are mutually exclusive")
-
     if not chat.input:
         message_text = str(chat.message or "").strip()
-        if not message_text:
-            raise HTTPException(status_code=400, detail="message or input is required")
         user_message = build_message("user", [text_block(message_text)])
     else:
         blocks: list[dict[str, Any]] = []
@@ -119,36 +123,30 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
             elif block.type == "document":
                 if block.data:
                     mime_type = block.mime_type or "application/pdf"
-                    if mime_type != "application/pdf":
-                        raise HTTPException(status_code=400, detail="unsupported document mime_type")
                     blocks.append(document_block(block.data, mime_type=mime_type, name=block.name or "document.pdf"))
                 else:
-                    if not block.path:
-                        raise HTTPException(status_code=400, detail="document input requires path or data")
-                    path = Path(resolve_path(block.path, cwd=cwd))
+                    path = Path(resolve_path(cast(str, block.path), cwd=cwd))
                     if not path.is_file():
                         raise HTTPException(status_code=400, detail=f"document file not found: {block.path}")
                     mime_type = block.mime_type or detect_document_mime_type(path)
                     if mime_type != "application/pdf":
                         raise HTTPException(status_code=400, detail=f"unsupported document file: {block.path}")
-                    data = b64encode(path.read_bytes()).decode("utf-8")
+                    data = b64encode(await asyncio.to_thread(path.read_bytes)).decode("utf-8")
                     blocks.append(document_block(data, mime_type=mime_type, name=block.name or path.name))
 
             else:  # image
                 if block.data:
-                    if not block.mime_type:
-                        raise HTTPException(status_code=400, detail="image data requires mime_type")
-                    blocks.append(image_block(block.data, mime_type=block.mime_type, name=block.name or "image"))
+                    blocks.append(
+                        image_block(block.data, mime_type=cast(str, block.mime_type), name=block.name or "image")
+                    )
                 else:
-                    if not block.path:
-                        raise HTTPException(status_code=400, detail="image input requires path or data")
-                    path = Path(resolve_path(block.path, cwd=cwd))
+                    path = Path(resolve_path(cast(str, block.path), cwd=cwd))
                     if not path.is_file():
                         raise HTTPException(status_code=400, detail=f"image file not found: {block.path}")
                     mime_type = block.mime_type or detect_image_mime_type(path)
                     if not mime_type:
                         raise HTTPException(status_code=400, detail=f"unsupported image file: {block.path}")
-                    data = b64encode(path.read_bytes()).decode("utf-8")
+                    data = b64encode(await asyncio.to_thread(path.read_bytes)).decode("utf-8")
                     blocks.append(image_block(data, mime_type=mime_type, name=block.name or path.name))
 
         if not blocks:
@@ -219,7 +217,8 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
         created = await store.create_session(session_id, cwd=cwd)
         session = created["session"]
 
-    agent = build_agent(
+    agent = await asyncio.to_thread(
+        build_agent,
         store=store,
         cwd=cwd,
         settings=settings,
@@ -243,11 +242,16 @@ async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
             detail["run"] = existing.info()
         raise HTTPException(status_code=409, detail=detail) from exc
 
-    return {"run": run, "session": session}
+    return ChatResponse(run=RunInfo.model_validate(run), session=session)
 
 
 @router.get("/runs/{run_id}/stream")
-async def stream_run(run_id: str, req: Request, runs: RunManagerDep, after: int = 0):
+async def stream_run(
+    run_id: Annotated[str, PathParam(min_length=1)],
+    req: Request,
+    runs: RunManagerDep,
+    after: Annotated[int, Query(ge=0)] = 0,
+) -> StreamingResponse:
     state = await runs.get_run(run_id)
     if not state:
         raise HTTPException(status_code=404, detail="run not found")
@@ -260,19 +264,21 @@ async def stream_run(run_id: str, req: Request, runs: RunManagerDep, after: int
 
 
 @router.post("/runs/{run_id}/cancel")
-async def cancel_run(run_id: str, runs: RunManagerDep):
+async def cancel_run(run_id: Annotated[str, PathParam(min_length=1)], runs: RunManagerDep) -> CancelRunResponse:
     run = await runs.cancel_run(run_id)
     if not run:
         raise HTTPException(status_code=404, detail="run not found")
-    return {"status": "ok", "run": run}
+    return CancelRunResponse(status="ok", run=RunInfo.model_validate(run))
 
 
 @router.post("/runs/{run_id}/decide")
-async def decide_run(run_id: str, body: DecideRequest, runs: RunManagerDep):
+async def decide_run(
+    run_id: Annotated[str, PathParam(min_length=1)], body: DecideRequest, runs: RunManagerDep
+) -> StatusResponse:
     resolved = await runs.resolve_decision(run_id, body.request_id, body.decision)
     if not resolved:
         raise HTTPException(status_code=404, detail="permission request not found")
-    return {"status": "ok"}
+    return StatusResponse(status="ok")
 
 
 def _make_review(runs: RunManager, session_id: str):
@@ -290,9 +296,9 @@ def _make_review(runs: RunManager, session_id: str):
 
 
 @router.get("/config")
-async def get_config(cwd: str | None = None):
+async def get_config(cwd: Annotated[str | None, Query()] = None) -> dict[str, Any]:
     resolved_cwd = os.path.abspath(cwd or os.getcwd())
-    settings = get_settings(resolved_cwd)
+    settings = await asyncio.to_thread(get_settings, resolved_cwd)
     try:
         resolved = resolve_provider(settings)
     except ValueError as exc:

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/routers/sessions.py

@@ -3,19 +3,21 @@
 from __future__ import annotations
 
 import os
+from typing import Annotated, Any
 from uuid import uuid4
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Query
+from fastapi import Path as PathParam
 
 from mycode.messages import ConversationMessage
 from mycode_cli.server.deps import RunManagerDep, StoreDep
-from mycode_cli.server.schemas import SessionCreateRequest
+from mycode_cli.server.schemas import SessionCreateRequest, StatusResponse
 
 router = APIRouter(prefix="/sessions", tags=["sessions"])
 
 
-def _redact_document_data(messages: list[ConversationMessage]) -> list[ConversationMessage]:
-    redacted: list[ConversationMessage] = []
+def _redact_document_data(messages: list[ConversationMessage]) -> list[dict[str, Any]]:
+    redacted: list[dict[str, Any]] = []
     for message in messages:
         content = []
         for block in message.get("content") or []:
@@ -29,16 +31,21 @@ def _redact_document_data(messages: list[ConversationMessage]) -> list[Conversat
 
 
 @router.post("")
-async def create_session(req: SessionCreateRequest, store: StoreDep):
+async def create_session(req: SessionCreateRequest, store: StoreDep) -> dict[str, Any]:
     cwd = os.path.abspath(req.cwd or os.getcwd())
     if not os.path.isdir(cwd):
         raise HTTPException(status_code=400, detail=f"Working directory does not exist: {cwd}")
     session_id = uuid4().hex
-    return await store.create_session(session_id, cwd=cwd)
+    data = await store.create_session(session_id, cwd=cwd)
+    return {"session": data["session"], "messages": data["messages"]}
 
 
 @router.get("")
-async def list_sessions(store: StoreDep, runs: RunManagerDep, cwd: str | None = None):
+async def list_sessions(
+    store: StoreDep,
+    runs: RunManagerDep,
+    cwd: Annotated[str | None, Query()] = None,
+) -> dict[str, Any]:
     sessions = await store.list_sessions(cwd=cwd)
     for session in sessions:
         session_id = str(session.get("id") or "")
@@ -47,7 +54,9 @@ async def list_sessions(store: StoreDep, runs: RunManagerDep, cwd: str | None =
 
 
 @router.get("/{session_id}")
-async def load_session(session_id: str, store: StoreDep, runs: RunManagerDep):
+async def load_session(
+    session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
+) -> dict[str, Any]:
     """Load a session, overlaying any active in-memory run state."""
 
     data = await store.load_session(session_id)
@@ -73,16 +82,20 @@ async def load_session(session_id: str, store: StoreDep, runs: RunManagerDep):
 
 
 @router.delete("/{session_id}")
-async def delete_session(session_id: str, store: StoreDep, runs: RunManagerDep):
+async def delete_session(
+    session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
+) -> StatusResponse:
     if await runs.has_active_run(session_id):
         raise HTTPException(status_code=409, detail="session has a running task")
     await store.delete_session(session_id)
-    return {"status": "ok"}
+    return StatusResponse(status="ok")
 
 
 @router.post("/{session_id}/clear")
-async def clear_session(session_id: str, store: StoreDep, runs: RunManagerDep):
+async def clear_session(
+    session_id: Annotated[str, PathParam(min_length=1)], store: StoreDep, runs: RunManagerDep
+) -> StatusResponse:
     if await runs.has_active_run(session_id):
         raise HTTPException(status_code=409, detail="session has a running task")
     await store.clear_session(session_id)
-    return {"status": "ok"}
+    return StatusResponse(status="ok")

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/routers/settings.py

@@ -317,12 +317,12 @@ def _atomic_write(path: Path, payload: dict[str, Any]) -> None:
 
 
 @router.get("/settings")
-async def get_settings_endpoint() -> dict[str, Any]:
+def get_settings_endpoint() -> dict[str, Any]:
     return _build_response(resolve_mycode_home() / "config.json")
 
 
 @router.put("/settings")
-async def put_settings_endpoint(payload: SettingsRequest) -> dict[str, Any]:
+def put_settings_endpoint(payload: SettingsRequest) -> dict[str, Any]:
     path = resolve_mycode_home() / "config.json"
     existing = _read_raw_config(path)
     incoming = copy.deepcopy(payload.config or {})

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/routers/workspaces.py

@@ -2,8 +2,9 @@
 
 import os
 from pathlib import Path
+from typing import Annotated
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Query
 
 router = APIRouter(prefix="/workspaces", tags=["workspaces"])
 
@@ -31,13 +32,16 @@ def _parse_workspace_roots() -> list[Path]:
 
 
 @router.get("/roots")
-async def list_workspace_roots():
+def list_workspace_roots() -> dict[str, list[str]]:
     """List workspace roots for browsing."""
     return {"roots": [str(root) for root in _parse_workspace_roots()]}
 
 
 @router.get("/browse")
-async def browse_workspaces(root: str, path: str | None = None):
+def browse_workspaces(
+    root: Annotated[str, Query(min_length=1)],
+    path: Annotated[str | None, Query()] = None,
+) -> dict[str, object]:
     """Browse directories within a workspace root."""
     root_path = None
     requested_root = Path(root).expanduser().resolve(strict=False)
@@ -87,6 +91,7 @@ async def browse_workspaces(root: str, path: str | None = None):
 
 
 @router.get("/cwd")
-async def get_cwd():
+def get_cwd() -> dict[str, object]:
     """Get current working directory."""
-    return {"cwd": os.getcwd(), "exists": Path(os.getcwd()).exists()}
+    cwd = os.getcwd()
+    return {"cwd": cwd, "exists": Path(cwd).exists()}

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/run_manager.py

@@ -47,6 +47,7 @@ class RunState:
     next_seq: int = 1
     task: asyncio.Task[None] | None = None
     finished_at: float | None = None
+    cancel_requested: bool = False
     condition: asyncio.Condition = field(default_factory=asyncio.Condition)
     pending_decisions: dict[str, asyncio.Future[ToolReviewDecision]] = field(default_factory=dict)
 
@@ -126,10 +127,13 @@ class RunManager:
         state = await self.get_run(run_id)
         if not state:
             return None
+        state.cancel_requested = True
         state.agent.cancel()
         for fut in state.pending_decisions.values():
             if not fut.done():
                 fut.cancel()
+        if state.task is not None:
+            await state.task
         return state.info()
 
     async def has_active_run(self, session_id: str) -> bool:
@@ -172,6 +176,9 @@ class RunManager:
         decision: ToolReviewDecision = "deny"
         try:
             decision = await future
+            if decision == "deny":
+                state.cancel_requested = True
+                state.agent.cancel()
             return decision
         except asyncio.CancelledError:
             # Treat cancellation as deny so the agent loop unwinds via its own cancel check.
@@ -222,7 +229,7 @@ class RunManager:
             last_error = str(exc)
             await self._append_event(state, Event("error", {"message": last_error}))
 
-        if last_error == "cancelled":
+        if state.cancel_requested or last_error == "cancelled":
             await self._finish_run(state, status="cancelled", error=last_error)
             return
 

{mycode_cli-0.8.6 → mycode_cli-0.8.7}/src/mycode_cli/server/schemas.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from typing import Any, Literal
+from typing import Any, Literal, Self
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 
 class ChatInputBlock(BaseModel):
@@ -18,6 +18,22 @@ class ChatInputBlock(BaseModel):
     name: str | None = None
     is_attachment: bool = False
 
+    @model_validator(mode="after")
+    def validate_shape(self) -> Self:
+        if self.type == "text":
+            return self
+
+        if not self.path and not self.data:
+            raise ValueError(f"{self.type} input requires path or data")
+
+        if self.type == "image" and self.data and not self.mime_type:
+            raise ValueError("image data requires mime_type")
+
+        if self.type == "document" and self.mime_type not in {None, "application/pdf"}:
+            raise ValueError("unsupported document mime_type")
+
+        return self
+
 
 class ChatRequest(BaseModel):
     """Request body for /chat."""
@@ -33,6 +49,16 @@ class ChatRequest(BaseModel):
     reasoning_effort: str | None = None
     rewind_to: int | None = Field(default=None, description="Visible message index for rewind.")
 
+    @model_validator(mode="after")
+    def validate_shape(self) -> Self:
+        has_message = bool((self.message or "").strip())
+        has_input = bool(self.input)
+        if has_message and has_input:
+            raise ValueError("message and input are mutually exclusive")
+        if not has_message and not has_input:
+            raise ValueError("message or input is required")
+        return self
+
 
 class SessionCreateRequest(BaseModel):
     """Request body for /sessions."""
@@ -82,3 +108,32 @@ class SettingsRequest(BaseModel):
     """Request body for PUT /settings — full replacement of global config."""
 
     config: dict[str, Any] | None = None
+
+
+class RunInfo(BaseModel):
+    """Public run state returned by the server."""
+
+    id: str
+    session_id: str
+    status: Literal["running", "completed", "failed", "cancelled"]
+    last_seq: int
+    error: str | None = None
+
+
+class ChatResponse(BaseModel):
+    """Response for POST /chat."""
+
+    run: RunInfo
+    session: dict[str, Any]
+
+
+class StatusResponse(BaseModel):
+    """Simple status response."""
+
+    status: Literal["ok"]
+
+
+class CancelRunResponse(StatusResponse):
+    """Response for POST /runs/{run_id}/cancel."""
+
+    run: RunInfo