mycode-cli 0.1.0__py3-none-any.whl

mycode/server/__init__.py

@@ -0,0 +1 @@
+"""FastAPI server interface."""

mycode/server/app.py

@@ -0,0 +1,52 @@
+"""FastAPI application entry point."""
+
+import logging
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from mycode.core.config import setup_logging
+from mycode.server.routers import chat_router, sessions_router, workspaces_router
+
+logger = logging.getLogger(__name__)
+
+
+def frontend_static_path() -> Path:
+    """Return the packaged frontend static directory."""
+
+    return Path(__file__).resolve().parent / "static"
+
+
+def create_app(*, serve_frontend: bool = True) -> FastAPI:
+    """Create the FastAPI app."""
+    setup_logging()
+    application = FastAPI(title="mycode")
+
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Mount API routers
+    application.include_router(chat_router, prefix="/api")
+    application.include_router(sessions_router, prefix="/api")
+    application.include_router(workspaces_router, prefix="/api")
+
+    if not serve_frontend:
+        logger.info("frontend disabled; starting in API-only mode")
+        return application
+
+    frontend_static = frontend_static_path()
+    if frontend_static.is_dir():
+        application.mount("/", StaticFiles(directory=str(frontend_static), html=True), name="frontend")
+    else:
+        logger.warning("frontend assets not found at %s; starting in API-only mode", frontend_static)
+
+    return application
+
+
+app = create_app()

mycode/server/deps.py

@@ -0,0 +1,29 @@
+"""Shared dependencies for server routers."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Annotated
+
+from fastapi import Depends
+
+from mycode.core.session import SessionStore
+from mycode.server.run_manager import RunManager
+
+
+@lru_cache
+def get_store() -> SessionStore:
+    """Return the shared session store for server requests."""
+
+    return SessionStore()
+
+
+@lru_cache
+def get_run_manager() -> RunManager:
+    """Return the shared in-process run manager."""
+
+    return RunManager()
+
+
+StoreDep = Annotated[SessionStore, Depends(get_store)]
+RunManagerDep = Annotated[RunManager, Depends(get_run_manager)]

mycode/server/routers/__init__.py

@@ -0,0 +1,7 @@
+"""API routers package."""
+
+from mycode.server.routers.chat import router as chat_router
+from mycode.server.routers.sessions import router as sessions_router
+from mycode.server.routers.workspaces import router as workspaces_router
+
+__all__ = ["chat_router", "sessions_router", "workspaces_router"]

mycode/server/routers/chat.py

@@ -0,0 +1,320 @@
+"""Chat and run streaming API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from base64 import b64encode
+from collections.abc import AsyncIterator
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import StreamingResponse
+
+from mycode.core.agent import Agent
+from mycode.core.config import (
+    get_settings,
+    normalize_reasoning_effort,
+    resolve_provider,
+    resolve_provider_choices,
+)
+from mycode.core.messages import build_message, flatten_message_text, image_block, text_block
+from mycode.core.providers import get_provider_adapter, provider_default_models
+from mycode.core.tools import detect_image_mime_type, resolve_path
+from mycode.server.deps import RunManagerDep, StoreDep
+from mycode.server.run_manager import ActiveRunError, RunState
+from mycode.server.schemas import ChatRequest, StreamEvent
+
+router = APIRouter()
+
+REASONING_EFFORT_OPTIONS = ("auto", "none", "low", "medium", "high", "xhigh")
+
+
+def _format_sse(event: StreamEvent) -> str:
+    return f"data: {json.dumps(event.model_dump(exclude_none=True), ensure_ascii=False)}\n\n"
+
+
+async def _stream_run(req: Request, state: RunState, after: int) -> AsyncIterator[str]:
+    last_seq = max(0, after)
+
+    while True:
+        if await req.is_disconnected():
+            return
+
+        async with state.condition:
+            pending = [event for event in state.events if int(event.get("seq") or 0) > last_seq]
+            finished = state.status != "running"
+
+            if not pending and not finished:
+                try:
+                    await asyncio.wait_for(state.condition.wait(), timeout=0.5)
+                except TimeoutError:
+                    continue
+                continue
+
+        for payload in pending:
+            if await req.is_disconnected():
+                return
+            yield _format_sse(StreamEvent(**payload))
+            last_seq = int(payload.get("seq") or last_seq)
+
+        if finished:
+            break
+
+    yield "data: [DONE]\n\n"
+
+
+@router.post("/chat")
+async def chat(chat: ChatRequest, store: StoreDep, runs: RunManagerDep):
+    cwd = os.path.abspath(chat.cwd or os.getcwd())
+    settings = get_settings(cwd)
+    resolved = resolve_provider(
+        settings,
+        provider_name=chat.provider,
+        model=chat.model,
+        api_key=chat.api_key,
+        api_base=chat.api_base,
+    )
+    request_effort = normalize_reasoning_effort(chat.reasoning_effort)
+    reasoning_effort = request_effort if request_effort is not None else resolved.reasoning_effort
+    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 chat.input:
+        blocks: list[dict[str, Any]] = []
+        for block in chat.input:
+            if block.type == "text":
+                text = str(block.text or "")
+                if text:
+                    blocks.append(text_block(text))
+                continue
+
+            if block.data:
+                # Inline base64 from web upload
+                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"))
+                continue
+
+            if not block.path:
+                raise HTTPException(status_code=400, detail="image input requires path or data")
+            resolved_path = resolve_path(block.path, cwd=cwd)
+            image_path = Path(resolved_path)
+            if not image_path.exists() or not image_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(image_path)
+            if not mime_type:
+                raise HTTPException(status_code=400, detail=f"unsupported image file: {block.path}")
+            image_data = b64encode(image_path.read_bytes()).decode("utf-8")
+            blocks.append(image_block(image_data, mime_type=mime_type, name=block.name or image_path.name))
+
+        if not blocks:
+            raise HTTPException(status_code=400, detail="input must include at least one non-empty block")
+        user_message = build_message("user", blocks)
+    else:
+        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)])
+
+    if any(isinstance(block, dict) and block.get("type") == "image" for block in user_message.get("content") or []):
+        if resolved.supports_image_input is not True:
+            raise HTTPException(status_code=400, detail="current model does not support image input")
+
+    data = await store.load_session(session_id)
+    session = (data or {}).get("session")
+    messages = (data or {}).get("messages") or []
+
+    if not session and chat.rewind_to is not None:
+        raise HTTPException(status_code=400, detail="rewind_to requires an existing session")
+
+    if not session:
+        title = flatten_message_text(user_message).replace("\n", " ").strip()[:48] or "New chat"
+        created = await store.create_session(
+            title,
+            session_id=session_id,
+            provider=resolved.provider,
+            model=resolved.model,
+            cwd=cwd,
+            api_base=resolved.api_base,
+        )
+        session = created["session"]
+
+    if chat.rewind_to is not None:
+        if not (0 <= chat.rewind_to < len(messages)):
+            raise HTTPException(
+                status_code=400,
+                detail=f"rewind_to must reference a visible message index between 0 and {len(messages) - 1}",
+            )
+
+        target = messages[chat.rewind_to]
+        blocks = target.get("content")
+        has_user_content = isinstance(blocks, list) and any(
+            isinstance(block, dict)
+            and ((block.get("type") == "text" and block.get("text")) or block.get("type") == "image")
+            for block in blocks
+        )
+
+        # Rewind only makes sense for real user prompts. Synthetic compact
+        # summaries, assistant messages, and tool-result-only user messages are
+        # not valid targets.
+        if target.get("role") != "user" or (target.get("meta") or {}).get("synthetic") or not has_user_content:
+            raise HTTPException(
+                status_code=400,
+                detail="rewind_to must reference a real user message",
+            )
+
+        messages = messages[: chat.rewind_to]
+
+    agent = Agent(
+        model=resolved.model,
+        provider=resolved.provider,
+        cwd=cwd,
+        session_dir=store.session_dir(session_id),
+        session_id=session_id,
+        api_key=resolved.api_key,
+        api_base=resolved.api_base,
+        messages=messages,
+        settings=settings,
+        reasoning_effort=reasoning_effort,
+        supports_image_input=resolved.supports_image_input,
+        max_tokens=resolved.max_tokens,
+        context_window=resolved.context_window,
+        compact_threshold=settings.compact_threshold,
+    )
+
+    rewind_persisted = False
+
+    async def on_persist(message: dict) -> None:
+        nonlocal rewind_persisted
+        if chat.rewind_to is not None and not rewind_persisted:
+            await store.append_rewind(session_id, chat.rewind_to)
+            rewind_persisted = True
+        await store.append_message(
+            session_id,
+            message,
+            provider=resolved.provider,
+            model=resolved.model,
+            cwd=cwd,
+            api_base=resolved.api_base,
+        )
+
+    try:
+        run = await runs.start_run(
+            session_id=session_id,
+            user_message=user_message,
+            base_messages=messages,
+            agent=agent,
+            on_persist=on_persist,
+        )
+    except ActiveRunError as exc:
+        existing = await runs.get_run(exc.run_id)
+        detail: dict[str, Any] = {"message": "session already has a running task"}
+        if existing:
+            detail["run"] = existing.info()
+        raise HTTPException(status_code=409, detail=detail) from exc
+
+    return {"run": run, "session": session}
+
+
+@router.get("/runs/{run_id}/stream")
+async def stream_run(run_id: str, req: Request, runs: RunManagerDep, after: int = 0):
+    state = await runs.get_run(run_id)
+    if not state:
+        raise HTTPException(status_code=404, detail="run not found")
+
+    return StreamingResponse(
+        _stream_run(req, state, after),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@router.post("/runs/{run_id}/cancel")
+async def cancel_run(run_id: str, runs: RunManagerDep):
+    run = await runs.cancel_run(run_id)
+    if not run:
+        raise HTTPException(status_code=404, detail="run not found")
+    return {"status": "ok", "run": run}
+
+
+@router.get("/config")
+async def get_config(cwd: str | None = None):
+    resolved_cwd = os.path.abspath(cwd or os.getcwd())
+    settings = get_settings(resolved_cwd)
+    try:
+        resolved = resolve_provider(settings)
+    except ValueError as exc:
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+
+    providers_info: dict[str, Any] = {}
+    for provider in resolve_provider_choices(settings):
+        provider_config = settings.providers.get(provider.provider_name or "")
+        models = (
+            list(provider_config.models)
+            if provider_config and provider_config.models
+            else list(provider_default_models(provider.provider))
+        )
+        if not models:
+            models = [provider.model]
+
+        info: dict[str, Any] = {
+            "name": provider.provider_name,
+            "provider": provider.provider,
+            "type": provider.provider,
+            "models": models,
+            "base_url": provider.api_base or "",
+            "has_api_key": True,
+        }
+
+        image_models: list[str] = []
+        adapter = get_provider_adapter(provider.provider)
+        if adapter.supports_reasoning_effort:
+            reasoning_models: list[str] = []
+            for model in models:
+                resolved_model = resolve_provider(
+                    settings,
+                    provider_name=provider.provider_name or provider.provider,
+                    model=model,
+                    api_base=provider.api_base or None,
+                )
+                if resolved_model.supports_reasoning is True:
+                    reasoning_models.append(model)
+                if resolved_model.supports_image_input is True:
+                    image_models.append(model)
+
+            info["supports_reasoning_effort"] = True
+            info["reasoning_models"] = reasoning_models
+            info["reasoning_effort"] = provider.reasoning_effort
+        else:
+            for model in models:
+                resolved_model = resolve_provider(
+                    settings,
+                    provider_name=provider.provider_name or provider.provider,
+                    model=model,
+                    api_base=provider.api_base or None,
+                )
+                if resolved_model.supports_image_input is True:
+                    image_models.append(model)
+
+        info["supports_image_input"] = bool(image_models)
+        info["image_input_models"] = image_models
+
+        providers_info[provider.provider_name or provider.provider] = info
+
+    return {
+        "providers": providers_info,
+        "default": {
+            "provider": resolved.provider_name,
+            "model": resolved.model,
+        },
+        "default_reasoning_effort": settings.default_reasoning_effort,
+        "reasoning_effort_options": REASONING_EFFORT_OPTIONS,
+        "cwd": resolved_cwd,
+        "workspace_root": settings.workspace_root,
+        "config_paths": settings.config_paths,
+    }

mycode/server/routers/sessions.py

@@ -0,0 +1,77 @@
+"""Session management API endpoints."""
+
+from __future__ import annotations
+
+import os
+
+from fastapi import APIRouter, HTTPException
+
+from mycode.core.config import get_settings, resolve_provider
+from mycode.server.deps import RunManagerDep, StoreDep
+from mycode.server.schemas import SessionCreateRequest
+
+router = APIRouter(prefix="/sessions", tags=["sessions"])
+
+
+@router.post("")
+async def create_session(req: SessionCreateRequest, store: StoreDep):
+    cwd = os.path.abspath(req.cwd or os.getcwd())
+    settings = get_settings(cwd)
+    resolved = resolve_provider(settings, provider_name=req.provider, model=req.model, api_base=req.api_base)
+    return await store.create_session(
+        req.title,
+        provider=resolved.provider,
+        model=resolved.model,
+        cwd=cwd,
+        api_base=resolved.api_base,
+    )
+
+
+@router.get("")
+async def list_sessions(store: StoreDep, runs: RunManagerDep, cwd: str | None = None):
+    sessions = await store.list_sessions(cwd=cwd)
+    for session in sessions:
+        session["is_running"] = await runs.has_active_run(session.get("id", ""))
+    return {"sessions": sessions}
+
+
+@router.get("/{session_id}")
+async def load_session(session_id: str, store: StoreDep, runs: RunManagerDep):
+    """Load a session, overlaying any active in-memory run state."""
+
+    data = await store.load_session(session_id)
+    session = data.get("session") if data else None
+    active = await runs.snapshot_session(session_id)
+    if active:
+        return {
+            "session": session,
+            "messages": active["messages"],
+            "active_run": active["run"],
+            "pending_events": active["pending_events"],
+        }
+
+    if not data:
+        return {"session": None, "messages": [], "active_run": None, "pending_events": []}
+
+    return {
+        "session": session,
+        "messages": data.get("messages") or [],
+        "active_run": None,
+        "pending_events": [],
+    }
+
+
+@router.delete("/{session_id}")
+async def delete_session(session_id: str, store: StoreDep, runs: RunManagerDep):
+    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"}
+
+
+@router.post("/{session_id}/clear")
+async def clear_session(session_id: str, store: StoreDep, runs: RunManagerDep):
+    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"}

mycode/server/routers/workspaces.py

@@ -0,0 +1,92 @@
+"""Workspace browsing API endpoints."""
+
+import os
+from pathlib import Path
+
+from fastapi import APIRouter
+
+router = APIRouter(prefix="/workspaces", tags=["workspaces"])
+
+
+def _parse_workspace_roots() -> list[Path]:
+    """Parse allowed workspace roots from environment variables."""
+    raw = os.environ.get("MYCODE_WORKSPACE_ROOTS") or os.environ.get("WORKSPACE_ROOTS")
+    if raw:
+        candidates = [item.strip() for item in raw.split(",") if item.strip()]
+    else:
+        candidates = [str(Path.home()), os.sep]
+
+    roots: list[Path] = []
+    seen: set[str] = set()
+    for value in candidates:
+        root = Path(value).expanduser().resolve(strict=False)
+        if not root.exists():
+            continue
+        key = str(root)
+        if key not in seen:
+            seen.add(key)
+            roots.append(root)
+
+    return roots or [Path(os.getcwd()).resolve(strict=False)]
+
+
+@router.get("/roots")
+async def list_workspace_roots():
+    """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):
+    """Browse directories within a workspace root."""
+    root_path = None
+    requested_root = Path(root).expanduser().resolve(strict=False)
+    for allowed_root in _parse_workspace_roots():
+        if requested_root == allowed_root:
+            root_path = allowed_root
+            break
+
+    if not root_path:
+        return {"root": root, "path": "", "current": "", "entries": [], "error": "Invalid root"}
+
+    rel_path = Path(path) if path else Path()
+    target = (root_path / rel_path).resolve(strict=False)
+
+    try:
+        target.relative_to(root_path)
+    except ValueError:
+        return {
+            "root": str(root_path),
+            "path": "",
+            "current": str(root_path),
+            "entries": [],
+            "error": "Path outside root",
+        }
+
+    try:
+        entries: list[dict[str, str]] = []
+        for entry in sorted(target.iterdir(), key=lambda item: item.name.lower()):
+            try:
+                if entry.name.startswith("."):
+                    continue
+                if entry.is_dir():
+                    entries.append({"name": entry.name, "path": entry.relative_to(root_path).as_posix()})
+            except OSError:
+                continue
+    except OSError as exc:
+        return {
+            "root": str(root_path),
+            "path": "",
+            "current": str(root_path),
+            "entries": [],
+            "error": str(exc),
+        }
+
+    current_path = "" if target == root_path else target.relative_to(root_path).as_posix()
+    return {"root": str(root_path), "path": current_path, "current": str(target), "entries": entries, "error": ""}
+
+
+@router.get("/cwd")
+async def get_cwd():
+    """Get current working directory."""
+    return {"cwd": os.getcwd(), "exists": Path(os.getcwd()).exists()}