remote-cli 0.1.0__py3-none-any.whl

remote_cli/daemon.py

@@ -0,0 +1,296 @@
+"""Background daemon server for remote-cli."""
+
+import asyncio
+import json
+import logging
+import os
+import signal
+import sys
+import time
+from pathlib import Path
+
+from .protocol import ActionType, Request, Response
+from .session import SessionManager
+from .utils import get_log_path, get_pid_path, get_socket_path
+
+logger = logging.getLogger("remote_cli.daemon")
+
+
+class DaemonServer:
+    """Unix Domain Socket server managing sessions."""
+
+    def __init__(self, socket_path: Path | None = None):
+        self.socket_path = socket_path or get_socket_path()
+        self.session_manager = SessionManager()
+        self.server: asyncio.Server | None = None
+        self.running = False
+
+    async def handle_client(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        try:
+            line = await reader.readline()
+            if not line:
+                return
+
+            req_data = json.loads(line.decode("utf-8"))
+            req = Request.model_validate(req_data)
+
+            if req.action == ActionType.ATTACH:
+                await self._handle_attach(req, reader, writer)
+                return
+
+            response = await self._dispatch_request(req)
+            resp_bytes = (response.model_dump_json() + "\n").encode("utf-8")
+            writer.write(resp_bytes)
+            await writer.drain()
+        except Exception as e:
+            logger.exception("Error handling client request")
+            err_resp = Response(success=False, error=str(e))
+            try:
+                writer.write((err_resp.model_dump_json() + "\n").encode("utf-8"))
+                await writer.drain()
+            except Exception:
+                pass
+        finally:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+
+    async def _handle_attach(
+        self, req: Request, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        session = self.session_manager.get_session(req.session_id or "")
+        if not session or session.status != "active":
+            resp = Response(
+                success=False,
+                error=f"Session {req.session_id} not found or not active",
+            )
+            writer.write((resp.model_dump_json() + "\n").encode("utf-8"))
+            await writer.drain()
+            return
+
+        # Send OK acknowledgment
+        resp = Response(success=True, message="ATTACH_STREAM_START")
+        writer.write((resp.model_dump_json() + "\n").encode("utf-8"))
+        await writer.drain()
+
+        # If client passed initial window size, apply it
+        if req.rows and req.cols:
+            session.resize(req.rows, req.cols)
+
+        # Attach writer to session
+        session.attach_client(writer)
+        try:
+            while True:
+                data = await reader.read(4096)
+                if not data:
+                    break
+                session.write_input(data)
+        except (asyncio.CancelledError, ConnectionResetError, BrokenPipeError):
+            pass
+        except Exception as e:
+            logger.debug(f"Attach stream read exception: {e}")
+        finally:
+            session.detach_client(writer)
+
+    async def _dispatch_request(self, req: Request) -> Response:
+        if req.action == ActionType.PING:
+            return Response(success=True, message="pong")
+
+        elif req.action == ActionType.CREATE_SESSION:
+            command = req.command or ["/bin/bash"]
+            rows = req.rows or 24
+            cols = req.cols or 80
+            session = self.session_manager.create_session(
+                command=command,
+                name=req.name,
+                rows=rows,
+                cols=cols,
+            )
+            return Response(
+                success=True,
+                message=f"Session {session.session_id} created",
+                data=session.get_info().model_dump(),
+            )
+
+        elif req.action == ActionType.LIST_SESSIONS:
+            sessions = [s.model_dump() for s in self.session_manager.list_sessions()]
+            return Response(success=True, data=sessions)
+
+        elif req.action == ActionType.GET_SESSION:
+            session = self.session_manager.get_session(req.session_id or "")
+            if not session:
+                return Response(success=False, error="Session not found")
+            return Response(success=True, data=session.get_info().model_dump())
+
+        elif req.action == ActionType.CLOSE_SESSION:
+            closed = self.session_manager.close_session(req.session_id or "")
+            if not closed:
+                return Response(success=False, error="Session not found")
+            return Response(success=True, message=f"Session {req.session_id} closed")
+
+        elif req.action == ActionType.EXEC_COMMAND:
+            session = self.session_manager.get_session(req.session_id or "")
+            if not session:
+                return Response(success=False, error="Session not found")
+            if not req.command_str:
+                return Response(success=False, error="No command provided to exec")
+            result = await session.execute_command(req.command_str, timeout=req.timeout or 30.0)
+            return Response(success=True, data=result.model_dump())
+
+        elif req.action == ActionType.SEND_INPUT:
+            session = self.session_manager.get_session(req.session_id or "")
+            if not session:
+                return Response(success=False, error="Session not found")
+
+            payload = b""
+            if req.ctrl_c:
+                payload = b"\x03"
+            elif req.ctrl_d:
+                payload = b"\x04"
+            elif req.text is not None:
+                text = req.text
+                if not req.no_newline:
+                    text += "\n"
+                payload = text.encode("utf-8")
+
+            session.write_input(payload)
+            return Response(success=True, message="Input sent")
+
+        elif req.action == ActionType.SNAPSHOT:
+            session = self.session_manager.get_session(req.session_id or "")
+            if not session:
+                return Response(success=False, error="Session not found")
+            text = session.screen.snapshot(clean=req.clean)
+            return Response(success=True, data={"snapshot": text})
+
+        elif req.action == ActionType.LOGS:
+            session = self.session_manager.get_session(req.session_id or "")
+            if not session:
+                return Response(success=False, error="Session not found")
+            lines = session.buffer.get_lines(req.lines or 100)
+            return Response(success=True, data={"lines": lines})
+
+        elif req.action == ActionType.RESIZE:
+            session = self.session_manager.get_session(req.session_id or "")
+            if not session:
+                return Response(success=False, error="Session not found")
+            if req.rows and req.cols:
+                session.resize(req.rows, req.cols)
+            return Response(success=True, message="Resized")
+
+        return Response(success=False, error=f"Unknown action: {req.action}")
+
+    async def start(self) -> None:
+        """Starts the Unix Domain Socket server."""
+        if self.socket_path.exists():
+            try:
+                self.socket_path.unlink()
+            except Exception:
+                pass
+
+        self.socket_path.parent.mkdir(parents=True, exist_ok=True)
+        self.server = await asyncio.start_unix_server(
+            self.handle_client, path=str(self.socket_path)
+        )
+        self.running = True
+
+        # Write PID file
+        pid_path = get_pid_path()
+        pid_path.write_text(str(os.getpid()))
+
+        logger.info(f"remote-cli daemon started at {self.socket_path} (pid: {os.getpid()})")
+        async with self.server:
+            await self.server.serve_forever()
+
+
+def run_daemon() -> None:
+    """Entry point for daemon process."""
+    log_file = get_log_path()
+    logging.basicConfig(
+        filename=str(log_file),
+        level=logging.INFO,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    )
+    server = DaemonServer()
+
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    def handle_signal():
+        for task in asyncio.all_tasks(loop):
+            task.cancel()
+        loop.stop()
+
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, handle_signal)
+
+    try:
+        loop.run_until_complete(server.start())
+    except (KeyboardInterrupt, asyncio.CancelledError):
+        pass
+    finally:
+        pid_path = get_pid_path()
+        if pid_path.exists():
+            pid_path.unlink()
+        sock_path = get_socket_path()
+        if sock_path.exists():
+            sock_path.unlink()
+
+
+def ensure_daemon_running() -> None:
+    """Checks if daemon is running; if not, spawns it in the background."""
+    from .client import Client
+
+    client = Client()
+    if client.ping():
+        return
+
+    # Clean up stale socket/pid
+    sock_path = get_socket_path()
+    if sock_path.exists():
+        try:
+            sock_path.unlink()
+        except Exception:
+            pass
+
+    import subprocess
+
+    cmd = [sys.executable, "-m", "remote_cli.daemon"]
+    subprocess.Popen(
+        cmd,
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+        close_fds=True,
+    )
+
+    # Wait for daemon to become ready
+    for _ in range(30):
+        time.sleep(0.1)
+        if client.ping():
+            return
+
+    raise RuntimeError("Failed to start background remote-cli daemon")
+
+
+def stop_daemon() -> bool:
+    """Stops the running daemon process."""
+    pid_path = get_pid_path()
+    if not pid_path.exists():
+        return False
+    try:
+        pid = int(pid_path.read_text().strip())
+        os.kill(pid, signal.SIGTERM)
+        time.sleep(0.3)
+        return True
+    except Exception:
+        return False
+
+
+if __name__ == "__main__":
+    run_daemon()

remote_cli/protocol.py

@@ -0,0 +1,66 @@
+"""IPC protocol definitions and models for remote-cli."""
+
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ActionType(StrEnum):
+    PING = "ping"
+    CREATE_SESSION = "create_session"
+    LIST_SESSIONS = "list_sessions"
+    GET_SESSION = "get_session"
+    CLOSE_SESSION = "close_session"
+    EXEC_COMMAND = "exec_command"
+    SEND_INPUT = "send_input"
+    SNAPSHOT = "snapshot"
+    LOGS = "logs"
+    RESIZE = "resize"
+    ATTACH = "attach"
+
+
+class SessionInfo(BaseModel):
+    session_id: str
+    name: str
+    command: list[str]
+    created_at: str
+    status: str  # "active", "exited"
+    exit_code: int | None = None
+    attached_clients: int = 0
+    rows: int = 24
+    cols: int = 80
+
+
+class Request(BaseModel):
+    action: ActionType
+    session_id: str | None = None
+    command: list[str] | None = None
+    command_str: str | None = None
+    name: str | None = None
+    rows: int | None = None
+    cols: int | None = None
+    text: str | None = None
+    no_newline: bool = False
+    ctrl_c: bool = False
+    ctrl_d: bool = False
+    timeout: float | None = 30.0
+    lines: int | None = 100
+    clean: bool = True
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class Response(BaseModel):
+    success: bool
+    message: str = ""
+    data: Any = None
+    error: str | None = None
+
+
+class ExecResult(BaseModel):
+    session_id: str
+    command: str
+    exit_code: int | None = None
+    output: str
+    duration: float
+    timed_out: bool = False

remote_cli/screen.py

@@ -0,0 +1,68 @@
+"""Terminal screen state and ring buffer management."""
+
+from collections import deque
+
+import pyte
+
+
+class VirtualScreen:
+    """Maintains a 2D virtual terminal screen state using pyte."""
+
+    def __init__(self, cols: int = 80, rows: int = 24, history: int = 1000):
+        self.cols = cols
+        self.rows = rows
+        self.screen = pyte.HistoryScreen(cols, rows, history=history)
+        self.stream = pyte.Stream(self.screen)
+
+    def feed(self, data: bytes) -> None:
+        """Feeds raw byte output from PTY into the terminal emulator."""
+        try:
+            text = data.decode("utf-8", errors="replace")
+            self.stream.feed(text)
+        except Exception:
+            pass
+
+    def resize(self, rows: int, cols: int) -> None:
+        """Resizes the virtual screen dimensions."""
+        self.rows = rows
+        self.cols = cols
+        self.screen.resize(lines=rows, columns=cols)
+
+    def snapshot(self, clean: bool = True) -> str:
+        """Returns the current rendered screen lines as a single string."""
+        lines = [line for line in self.screen.display]
+        if clean:
+            # Strip trailing spaces on each line
+            lines = [line.rstrip() for line in lines]
+            # Strip trailing blank lines
+            while lines and not lines[-1]:
+                lines.pop()
+        return "\n".join(lines)
+
+
+class RingBuffer:
+    """Thread-safe and memory-bounded ring buffer for recent log output."""
+
+    def __init__(self, max_lines: int = 10000, max_bytes: int = 5 * 1024 * 1024):
+        self.max_lines = max_lines
+        self.max_bytes = max_bytes
+        self._raw_chunks = deque()
+        self._total_bytes = 0
+
+    def append(self, data: bytes) -> None:
+        self._raw_chunks.append(data)
+        self._total_bytes += len(data)
+        while self._total_bytes > self.max_bytes and len(self._raw_chunks) > 1:
+            popped = self._raw_chunks.popleft()
+            self._total_bytes -= len(popped)
+
+    def get_raw_bytes(self) -> bytes:
+        return b"".join(self._raw_chunks)
+
+    def get_lines(self, num_lines: int = 100) -> list[str]:
+        raw = self.get_raw_bytes()
+        text = raw.decode("utf-8", errors="replace")
+        all_lines = text.splitlines()
+        if num_lines <= 0:
+            return all_lines
+        return all_lines[-num_lines:]