agentpool 2.1.9__py3-none-any.whl → 2.5.0__py3-none-any.whl

agentpool_server/opencode_server/routes/permission_routes.py

@@ -0,0 +1,63 @@
+"""Permission routes for OpenCode TUI compatibility."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models.events import PermissionResolvedEvent
+from agentpool_server.opencode_server.routes.session_routes import PermissionResponse
+
+
+router = APIRouter(prefix="/permission", tags=["permission"])
+
+
+@router.post("/{permission_id}/reply")
+async def reply_to_permission(
+    permission_id: str,
+    body: PermissionResponse,
+    state: StateDep,
+) -> bool:
+    """Respond to a pending permission request (OpenCode TUI compatibility).
+
+    This endpoint handles the OpenCode TUI's expected format:
+    POST /permission/{permission_id}/reply
+
+    The response can be:
+    - "once": Allow this tool execution once
+    - "always": Always allow this tool (remembered for session)
+    - "reject": Reject this tool execution
+    """
+    print(f"DEBUG permission endpoint: received reply '{body.reply}' for perm_id={permission_id}")
+    print(f"DEBUG permission endpoint: searching in {len(state.input_providers)} sessions")
+    # Find which session has this permission request
+    for session_id, input_provider in state.input_providers.items():
+        pending_perms = list(input_provider._pending_permissions.keys())
+        print(
+            f"DEBUG permission endpoint: session {session_id} has "
+            f"{len(pending_perms)} pending: {pending_perms}"
+        )
+        # Check if this permission belongs to this session
+        if permission_id in input_provider._pending_permissions:
+            print(f"DEBUG permission endpoint: found permission in session {session_id}")
+            # Resolve the permission
+            resolved = input_provider.resolve_permission(permission_id, body.reply)
+            print(f"DEBUG permission endpoint: resolve_permission returned {resolved}")
+            if not resolved:
+                raise HTTPException(
+                    status_code=404,
+                    detail="Permission not found or already resolved",
+                )
+
+            await state.broadcast_event(
+                PermissionResolvedEvent.create(
+                    session_id=session_id,
+                    request_id=permission_id,
+                    reply=body.reply,
+                )
+            )
+
+            return True
+
+    # Permission not found in any session
+    raise HTTPException(status_code=404, detail="Permission not found")

agentpool_server/opencode_server/routes/pty_routes.py

@@ -0,0 +1,300 @@
+"""PTY (Pseudo-Terminal) routes.
+
+Uses the agent's execution environment PTY manager for terminal sessions.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from fastapi import APIRouter, HTTPException, WebSocket, WebSocketDisconnect  # noqa: TC002
+
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.models import PtyCreateRequest, PtyInfo, PtyUpdateRequest
+
+
+if TYPE_CHECKING:
+    from exxec.pty_manager import PtyManagerProtocol
+
+    from agentpool_server.opencode_server.state import ServerState
+
+
+router = APIRouter(prefix="/pty", tags=["pty"])
+
+
+@dataclass
+class PtySession:
+    """Active PTY session with WebSocket subscribers."""
+
+    pty_id: str
+    subscribers: set[WebSocket] = field(default_factory=set)
+    read_task: asyncio.Task[Any] | None = None
+    buffer: str = ""
+
+
+# Track WebSocket subscribers per PTY session
+_pty_sessions: dict[str, PtySession] = {}
+
+
+def _get_pty_manager(state: StateDep) -> PtyManagerProtocol:
+    """Get PTY manager from agent's execution environment.
+
+    Args:
+        state: Server state with agent
+
+    Returns:
+        PTY manager from the agent's execution environment
+
+    Raises:
+        HTTPException: If PTY is not supported
+    """
+    try:
+        return state.agent.env.get_pty_manager()
+    except NotImplementedError as e:
+        raise HTTPException(
+            status_code=501, detail="PTY not supported by this execution environment"
+        ) from e
+
+
+def _convert_pty_info(info: Any, title: str | None = None) -> PtyInfo:
+    """Convert exxec PtyInfo to OpenCode PtyInfo model.
+
+    Args:
+        info: PtyInfo from exxec
+        title: Optional title override
+
+    Returns:
+        OpenCode PtyInfo model
+    """
+    return PtyInfo(
+        id=info.id,
+        title=title or f"Terminal {info.id[-4:]}",
+        command=info.command,
+        args=info.args,
+        cwd=info.cwd or "",
+        status=info.status,
+        pid=info.pid,
+    )
+
+
+@router.get("")
+async def list_ptys(state: StateDep) -> list[PtyInfo]:
+    """List all PTY sessions."""
+    manager = _get_pty_manager(state)
+    sessions = await manager.list_sessions()
+    return [_convert_pty_info(s) for s in sessions]
+
+
+@router.post("")
+async def create_pty(request: PtyCreateRequest, state: StateDep) -> PtyInfo:
+    """Create a new PTY session."""
+    from agentpool_server.opencode_server.models.events import PtyCreatedEvent
+
+    manager = _get_pty_manager(state)
+    # Limit number of PTY sessions to prevent resource exhaustion
+    sessions = await manager.list_sessions()
+    if len(sessions) >= 20:  # Max 20 concurrent PTY sessions  # noqa: PLR2004
+        detail = f"Too many PTY sessions ({len(sessions)}). Close some terminals first."
+        raise HTTPException(status_code=429, detail=detail)
+
+    # Use working dir from state if not specified
+    cwd = request.cwd or state.working_dir
+    print(f"Creating PTY: command={request.command}, args={request.args}, cwd={cwd}")
+    try:
+        info = await manager.create(
+            command=request.command,
+            args=request.args,
+            cwd=cwd,
+            env=request.env,
+        )
+        print(f"PTY created successfully: {info.id}, status={info.status}")
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Failed to create PTY: {e}") from e
+
+    pty_id = info.id
+    title = request.title or f"Terminal {pty_id[-4:]}"
+    # Create session tracker for WebSocket subscribers
+    session = PtySession(pty_id=pty_id)
+    _pty_sessions[pty_id] = session
+    print(f"PTY session registered: {pty_id}, total sessions: {len(_pty_sessions)}")
+    # Start background task to read output and distribute to subscribers
+    session.read_task = asyncio.create_task(_read_pty_output(manager, pty_id, state))
+    pty_info = _convert_pty_info(info, title=title)
+    # Broadcast PTY created event
+    event = PtyCreatedEvent.create(info=pty_info.model_dump(by_alias=True))
+    await state.broadcast_event(event)
+    return pty_info
+
+
+async def _read_pty_output(manager: PtyManagerProtocol, pty_id: str, state: ServerState) -> None:
+    """Background task to read PTY output and distribute to subscribers."""
+    from agentpool_server.opencode_server.models.events import PtyExitedEvent
+
+    session = _pty_sessions.get(pty_id)
+    if not session:
+        return
+
+    exit_code = 0
+    try:
+        async for data in manager.stream(pty_id):
+            decoded = data.decode("utf-8", errors="replace")
+
+            if session.subscribers:
+                # Send to all connected WebSocket clients
+                disconnected: set[WebSocket] = set()
+                for ws in session.subscribers:
+                    try:
+                        await ws.send_text(decoded)
+                    except Exception:  # noqa: BLE001
+                        disconnected.add(ws)
+                session.subscribers -= disconnected
+            else:
+                # Buffer output if no subscribers
+                session.buffer += decoded
+                # Limit buffer size
+                if len(session.buffer) > 100000:  # noqa: PLR2004
+                    session.buffer = session.buffer[-50000:]
+
+    except asyncio.CancelledError:
+        return  # Don't broadcast exit if cancelled
+    except Exception:  # noqa: BLE001
+        exit_code = -1
+
+    # Stream ended - process exited, broadcast event
+    event = PtyExitedEvent.create(pty_id=pty_id, exit_code=exit_code)
+    await state.broadcast_event(event)
+
+
+@router.get("/{pty_id}")
+async def get_pty(pty_id: str, state: StateDep) -> PtyInfo:
+    """Get PTY session details."""
+    manager = _get_pty_manager(state)
+    info = await manager.get_info(pty_id)
+    if not info:
+        raise HTTPException(status_code=404, detail="PTY session not found")
+    return _convert_pty_info(info)
+
+
+@router.put("/{pty_id}")
+@router.patch("/{pty_id}")
+async def update_pty(pty_id: str, request: PtyUpdateRequest, state: StateDep) -> PtyInfo:
+    """Update PTY session (title, resize)."""
+    from exxec.pty_manager import PtySize
+
+    from agentpool_server.opencode_server.models.events import PtyUpdatedEvent
+
+    manager = _get_pty_manager(state)
+    info = await manager.get_info(pty_id)
+    if not info:
+        raise HTTPException(status_code=404, detail="PTY session not found")
+
+    # Handle resize if requested
+    if request.size:
+        await manager.resize(pty_id, PtySize(rows=request.size.rows, cols=request.size.cols))
+        # Refresh info after resize
+        info = await manager.get_info(pty_id)
+        if not info:
+            raise HTTPException(status_code=404, detail="PTY session not found after resize")
+
+    # Title is handled at the API level, not in the PTY manager
+    title = request.title if request.title else f"Terminal {pty_id[-4:]}"
+    pty_info = _convert_pty_info(info, title=title)
+    # Broadcast PTY updated event
+    event = PtyUpdatedEvent.create(info=pty_info.model_dump(by_alias=True))
+    await state.broadcast_event(event)
+    return pty_info
+
+
+@router.delete("/{pty_id}")
+async def remove_pty(pty_id: str, state: StateDep) -> dict[str, bool]:
+    """Remove/kill PTY session."""
+    from agentpool_server.opencode_server.models.events import PtyDeletedEvent
+
+    manager = _get_pty_manager(state)
+    # Kill the PTY session
+    success = await manager.kill(pty_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="PTY session not found")
+    # Cleanup session tracker
+    session = _pty_sessions.pop(pty_id, None)
+    if session:
+        # Cancel read task
+        if session.read_task and not session.read_task.done():
+            session.read_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await session.read_task
+
+        # Close all WebSocket connections
+        for ws in session.subscribers:
+            with contextlib.suppress(Exception):
+                await ws.close()
+
+    # Broadcast PTY deleted event
+    event = PtyDeletedEvent.create(pty_id=pty_id)
+    await state.broadcast_event(event)
+
+    return {"success": True}
+
+
+@router.websocket("/{pty_id}/connect")
+async def connect_pty(websocket: WebSocket, pty_id: str) -> None:
+    """Connect to PTY via WebSocket for interactive terminal."""
+    # Get state from websocket's app
+
+    state: ServerState = websocket.app.state.server_state
+    try:
+        manager = _get_pty_manager(state)
+    except HTTPException:
+        # Must accept before we can close
+        await websocket.accept()
+        await websocket.close(code=1003, reason="PTY not supported")
+        return
+    except Exception as e:  # noqa: BLE001
+        await websocket.accept()
+        await websocket.close(code=1011, reason=f"Error: {e}")
+        return
+
+    # Check if PTY exists - if not, immediately reject like OpenCode does
+    info = await manager.get_info(pty_id)
+    if not info:
+        await websocket.accept()
+        await websocket.close(code=1003, reason="PTY session not found")
+        return
+
+    # PTY exists, accept the WebSocket connection
+    await websocket.accept()
+    # Get or create session tracker
+    if pty_id not in _pty_sessions:
+        _pty_sessions[pty_id] = PtySession(pty_id=pty_id)
+    session = _pty_sessions[pty_id]
+    session.subscribers.add(websocket)
+    # Send buffered output
+    if session.buffer:
+        try:
+            await websocket.send_text(session.buffer)
+            session.buffer = ""
+        except Exception:  # noqa: BLE001
+            pass
+
+    try:
+        while True:
+            # Receive input from client
+            data = await websocket.receive_text()
+            # Write to PTY stdin
+            info = await manager.get_info(pty_id)
+            if info and info.status == "running":
+                try:
+                    await manager.write(pty_id, data.encode())
+                except Exception:  # noqa: BLE001
+                    break
+            else:
+                break
+    except WebSocketDisconnect:
+        pass
+    except Exception:  # noqa: BLE001
+        pass
+    finally:
+        session.subscribers.discard(websocket)

agentpool_server/opencode_server/routes/question_routes.py

@@ -0,0 +1,128 @@
+"""Question routes for OpenCode compatibility."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+
+from agentpool_server.opencode_server.dependencies import StateDep
+from agentpool_server.opencode_server.input_provider import OpenCodeInputProvider
+from agentpool_server.opencode_server.models.events import (
+    QuestionRejectedEvent,
+    QuestionRepliedEvent,
+)
+from agentpool_server.opencode_server.models.question import QuestionReply, QuestionRequest
+
+
+router = APIRouter(prefix="/question", tags=["question"])
+
+
+@router.get("/", response_model=list[QuestionRequest])
+async def list_questions(state: StateDep) -> list[QuestionRequest]:
+    """List all pending question requests.
+
+    Returns a list of all pending questions awaiting user response.
+    """
+    questions = []
+    for question_id, pending in state.pending_questions.items():
+        questions.append(
+            QuestionRequest(
+                id=question_id,
+                session_id=pending.session_id,
+                questions=pending.questions,
+                tool=pending.tool,
+            )
+        )
+    return questions
+
+
+@router.post("/{requestID}/reply")
+async def reply_to_question(
+    requestID: str,  # noqa: N803
+    reply: QuestionReply,
+    state: StateDep,
+) -> bool:
+    """Reply to a question request.
+
+    The user provides answers to the questions. Answers must be provided
+    as an array of arrays, where each inner array contains the selected
+    label(s) for that question.
+
+    Args:
+        requestID: The question request ID
+        reply: The user's answers
+        state: Server state
+
+    Returns:
+        True if the question was resolved successfully
+
+    Raises:
+        HTTPException: If question not found or invalid provider
+    """
+    pending = state.pending_questions.get(requestID)
+    if not pending:
+        raise HTTPException(status_code=404, detail="Question request not found")
+
+    session_id = pending.session_id
+    provider = state.input_providers.get(session_id)
+
+    if not isinstance(provider, OpenCodeInputProvider):
+        raise HTTPException(status_code=500, detail="Invalid provider for session")
+
+    # Resolve via provider
+    success = provider.resolve_question(requestID, reply.answers)
+
+    if not success:
+        raise HTTPException(status_code=404, detail="Question already resolved")
+
+    # Broadcast replied event
+    event = QuestionRepliedEvent.create(
+        session_id=session_id,
+        request_id=requestID,
+        answers=reply.answers,
+    )
+    await state.broadcast_event(event)
+
+    return True
+
+
+@router.post("/{requestID}/reject")
+async def reject_question(
+    requestID: str,  # noqa: N803
+    state: StateDep,
+) -> bool:
+    """Reject a question request.
+
+    Called when the user dismisses the question without providing an answer.
+
+    Args:
+        requestID: The question request ID
+        state: Server state
+
+    Returns:
+        True if the question was rejected successfully
+
+    Raises:
+        HTTPException: If question not found
+    """
+    pending = state.pending_questions.get(requestID)
+    if not pending:
+        raise HTTPException(status_code=404, detail="Question request not found")
+
+    session_id = pending.session_id
+    future = pending.future
+
+    # Cancel the future
+    if not future.done():
+        future.cancel()
+
+    # Remove from pending
+    del state.pending_questions[requestID]
+
+    # Broadcast rejected event
+    event = QuestionRejectedEvent.create(
+        session_id=session_id,
+        request_id=requestID,
+    )
+    await state.broadcast_event(event)
+
+    return True