monoco-toolkit 0.2.5__py3-none-any.whl → 0.2.6__py3-none-any.whl

monoco/features/pty/core.py

@@ -1,185 +0,0 @@
-
-import asyncio
-import os
-import pty
-import select
-import signal
-import struct
-import fcntl
-import termios
-import logging
-from typing import Dict, Optional, Tuple, Any
-
-logger = logging.getLogger("monoco.pty")
-
-class PTYSession:
-    """
-    Manages a single PTY session connected to a subprocess (shell).
-    """
-    def __init__(self, session_id: str, cmd: list[str], env: Optional[Dict[str, str]] = None, cwd: Optional[str] = None):
-        self.session_id = session_id
-        self.cmd = cmd
-        self.env = env or os.environ.copy()
-        self.cwd = cwd or os.getcwd()
-        
-        self.fd: Optional[int] = None
-        self.pid: Optional[int] = None
-        self.proc = None # subprocess.Popen object
-        self.running = False
-        self.loop = asyncio.get_running_loop()
-
-    def start(self, cols: int = 80, rows: int = 24):
-        """
-        Spawn a subprocess connected to a new PTY using subprocess.Popen.
-        This provides better safety in threaded/asyncio environments than pty.fork().
-        """
-        import subprocess
-
-        # 1. Open PTY pair
-        master_fd, slave_fd = pty.openpty()
-        
-        # 2. Set initial size
-        self._set_winsize(master_fd, rows, cols)
-
-        try:
-            # 3. Spawn process
-            # start_new_session=True executes setsid()
-            self.proc = subprocess.Popen(
-                self.cmd,
-                stdin=slave_fd,
-                stdout=slave_fd,
-                stderr=slave_fd,
-                cwd=self.cwd,
-                env=self.env,
-                start_new_session=True,
-                close_fds=True # Important to close other FDs in child
-            )
-            
-            self.pid = self.proc.pid
-            self.fd = master_fd
-            self.running = True
-            
-            # 4. Close slave fd in parent (child has it open now)
-            os.close(slave_fd)
-            
-            logger.info(f"Started session {self.session_id} (PID: {self.pid})")
-            
-        except Exception as e:
-            logger.error(f"Failed to spawn process: {e}")
-            # Ensure we clean up fds if spawn fails
-            try:
-                os.close(master_fd)
-            except: pass
-            try:
-                os.close(slave_fd)
-            except: pass
-            raise e
-
-
-    def resize(self, cols: int, rows: int):
-        """
-        Resize the PTY.
-        """
-        if self.fd and self.running:
-            self._set_winsize(self.fd, rows, cols)
-
-    def write(self, data: bytes):
-        """
-        Write input data (from websocket) to the PTY master fd.
-        """
-        if self.fd and self.running:
-            os.write(self.fd, data)
-
-    async def read(self) -> bytes:
-        """
-        Read output data from PTY master fd (to forward to websocket).
-        """
-        if not self.fd or not self.running:
-            return b""
-            
-        try:
-            # Run in executor to avoid blocking the event loop
-            # pty read is blocking
-            return await self.loop.run_in_executor(None, self._read_blocking)
-        except OSError:
-            return b""
-
-    def _read_blocking(self) -> bytes:
-        try:
-            return os.read(self.fd, 1024)
-        except OSError:
-            return b""
-
-    def terminate(self):
-        """
-        Terminate the process and close the PTY.
-        """
-        self.running = False
-        
-        # Use Popen object if available
-        if self.proc:
-            try:
-                self.proc.terminate()
-                try:
-                    self.proc.wait(timeout=1.0)
-                except:
-                    # Force kill if not terminated
-                    self.proc.kill()
-                    self.proc.wait()
-            except Exception as e:
-                logger.error(f"Error terminating process: {e}")
-            self.proc = None
-            self.pid = None
-        elif self.pid:
-            # Fallback for legacy or if Popen obj lost
-            try:
-                os.kill(self.pid, signal.SIGTERM)
-                os.waitpid(self.pid, 0) # Reap zombie
-            except OSError:
-                pass
-            self.pid = None
-            
-        if self.fd:
-            try:
-                os.close(self.fd)
-            except OSError:
-                pass
-            self.fd = None
-        logger.info(f"Terminated session {self.session_id}")
-
-    def _set_winsize(self, fd: int, row: int, col: int, xpix: int = 0, ypix: int = 0):
-        winsize = struct.pack("HHHH", row, col, xpix, ypix)
-        fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
-
-
-class PTYManager:
-    """
-    Singleton to manage multiple PTY sessions.
-    """
-    def __init__(self):
-        self.sessions: Dict[str, PTYSession] = {}
-
-    def create_session(self, session_id: str, cwd: str, cmd: list[str] = ["/bin/zsh"], env: Dict = None) -> PTYSession:
-        if session_id in self.sessions:
-            # In a real app, we might want to attach to existing?
-            # For now, kill and recreate (or error)
-            self.close_session(session_id)
-            
-        session = PTYSession(session_id, cmd, env, cwd)
-        self.sessions[session_id] = session
-        return session
-
-    def get_session(self, session_id: str) -> Optional[PTYSession]:
-        return self.sessions.get(session_id)
-
-    def close_session(self, session_id: str):
-        if session_id in self.sessions:
-            self.sessions[session_id].terminate()
-            del self.sessions[session_id]
-
-    def close_all_sessions(self):
-        """
-        Terminate all active PTY sessions.
-        """
-        for session_id in list(self.sessions.keys()):
-            self.close_session(session_id)

monoco/features/pty/router.py

@@ -1,138 +0,0 @@
-
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Query
-from pydantic import BaseModel
-from typing import Optional, Dict
-import json
-import asyncio
-import logging
-import os
-from pathlib import Path
-from monoco.features.pty.core import PTYManager
-from monoco.core.config import get_config
-
-# We will use dependency injection or a global singleton for now
-# Ideally attached to app state
-pty_manager = PTYManager()
-
-router = APIRouter(prefix="/api/v1/pty", tags=["pty"])
-
-logger = logging.getLogger("monoco.pty")
-
-@router.websocket("/ws/{session_id}")
-async def websocket_pty_endpoint(
-    websocket: WebSocket, 
-    session_id: str,
-    cwd: Optional[str] = Query(None),
-    cols: int = Query(80), 
-    rows: int = Query(24),
-    env: Optional[str] = Query(None) # JSON-encoded env vars
-):
-    await websocket.accept()
-    
-    # Determine working directory
-    # 1. Provide explicit CWD in query
-    # 2. Or fallback to ProjectRoot from env (if integrated)
-    # 3. Or fallback to process CWD
-    
-    # Since monoco pty runs as a separate service, we expect CWD to be passed
-    # or we default to where monoco pty was started
-    working_dir = cwd if cwd else os.getcwd()
-    
-    # Prepare environment
-    env_vars = os.environ.copy()
-    env_vars["TERM"] = "xterm-256color"
-    env_vars["COLORTERM"] = "truecolor"
-    if "SHELL" not in env_vars:
-        env_vars["SHELL"] = "/bin/zsh"
-    if "HOME" not in env_vars:
-        import pathlib
-        env_vars["HOME"] = str(pathlib.Path.home())
-
-    # Filter out Trae/Gemini specific variables to avoid shell integration conflicts
-    # This prevents the shell from trying to write to IDE-specific logs which causes EPERM
-    keys_to_remove = [k for k in env_vars.keys() if k.startswith("TRAE_") or k.startswith("GEMINI_") or k == "AI_AGENT"]
-    for k in keys_to_remove:
-        del env_vars[k]
-
-    if env:
-        try:
-            custom_env = json.loads(env)
-            env_vars.update(custom_env)
-        except:
-            logger.warning("Failed to parse custom env vars")
-
-    # Start Session
-    try:
-        session = pty_manager.create_session(
-            session_id=session_id, 
-            cwd=working_dir,
-            cmd=["/bin/zsh", "-l"], # Use login shell to ensure full user environment
-            env=env_vars
-        )
-        session.start(cols, rows)
-    except Exception as e:
-        logger.error(f"Failed to start session: {e}")
-        await websocket.close(code=1011)
-        return
-
-    # Pipe Loop
-    reader_task = None
-    try:
-        # Task to read from PTY and send to WebSocket
-        async def pty_reader():
-            while session.running:
-                data = await session.read()
-                if not data:
-                    break
-                # xterm.js expects string or binary. We send string/bytes.
-                # Usually text is fine, but binary is safer for control codes.
-                await websocket.send_bytes(data)
-            
-            # If PTY exits, close WS
-            await websocket.close()
-
-        reader_task = asyncio.create_task(pty_reader())
-
-        # Main loop: Read from WebSocket and write to PTY
-        try:
-            while True:
-                # Receive message from Client (xterm.js)
-                # Message can be simple input string, or a JSON command (resize)
-                message = await websocket.receive()
-                
-                if message["type"] == "websocket.disconnect":
-                    raise WebSocketDisconnect(code=message.get("code", 1000))
-                
-                if "text" in message:
-                    payload = message["text"]
-                    
-                    # Check if it's a control message (Hack: usually client sends raw input)
-                    # We can enforce a protocol: binary for Input, text JSON for Control.
-                    try:
-                        # Try parsing as JSON control message
-                        cmd = json.loads(payload)
-                        if cmd.get("type") == "resize":
-                            session.resize(cmd["cols"], cmd["rows"])
-                            continue
-                    except:
-                        pass # Not JSON, treat as raw input
-                    
-                    session.write(payload.encode())
-                    
-                elif "bytes" in message:
-                    session.write(message["bytes"])
-        except RuntimeError:
-            # Handle "Cannot call 'receive' once a disconnect message has been received"
-            # This happens if Starlette/FastAPI already processed the disconnect internally
-            # but we called receive() again.
-            logger.info(f"Runtime disconnect for session {session_id}")
-
-    except WebSocketDisconnect:
-        logger.info(f"Client disconnected for session {session_id}")
-    except Exception as e:
-        logger.error(f"WebSocket error: {e}")
-    finally:
-        # Cleanup
-        pty_manager.close_session(session_id)
-        if reader_task and not reader_task.done():
-            reader_task.cancel()

monoco/features/pty/server.py

@@ -1,56 +0,0 @@
-import logging
-import signal
-import sys
-from typing import Optional
-from pathlib import Path
-from contextlib import asynccontextmanager
-import uvicorn
-from fastapi import FastAPI
-from monoco.features.pty.router import router as pty_router, pty_manager
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    # Startup
-    yield
-    # Shutdown
-    logging.info("Shutting down PTY manager and cleaning up sessions...")
-    pty_manager.close_all_sessions()
-
-def run_pty_server(host: str = "127.0.0.1", port: int = 3124, cwd: Optional[Path] = None):
-    """
-    Entry point for the 'monoco pty' command.
-    """
-    # Configure Logging
-    logging.basicConfig(level=logging.INFO)
-    
-    # Register a manual signal handler to ensure we catch termination even if uvicorn misses it
-    # or if we are stuck before uvicorn starts.
-    def handle_signal(signum, frame):
-        logging.info(f"Received signal {signum}, initiating shutdown...")
-        # We rely on uvicorn to handle the actual exit loop for SIGINT/SIGTERM usually,
-        # but having this log confirms propagation.
-        # If uvicorn is running, it should catch this first. 
-        # If not, we exit manually.
-        sys.exit(0)
-
-    # Note: Uvicorn overwrites SIGINT/SIGTERM handlers by default. 
-    # relying on lifespan is the standard "Uvicorn way".
-    
-    app = FastAPI(title="Monoco PTY Service", lifespan=lifespan)
-    app.include_router(pty_router)
-    
-    # If cwd is provided, we might want to set it as current process CWD
-    # so that new sessions default to it.
-    if cwd and cwd.exists():
-        import os
-        os.chdir(cwd)
-        logging.info(f"PTY Service Root: {cwd}")
-
-    logging.info(f"Starting Monoco PTY Service on ws://{host}:{port}")
-    try:
-        uvicorn.run(app, host=host, port=port)
-    except KeyboardInterrupt:
-        pass
-    finally:
-        # Final safety net
-        pty_manager.close_all_sessions()