castrel-proxy 0.1.0__py3-none-any.whl

castrel_proxy/core/client_id.py

@@ -0,0 +1,94 @@
+"""
+Client Unique Identifier Generation Module
+
+Generates stable client IDs based on machine characteristics (hostname + MAC address)
+"""
+
+import hashlib
+import platform
+import socket
+import uuid
+from typing import Dict
+
+
+def get_client_id() -> str:
+    """
+    Generate unique client identifier based on machine characteristics
+
+    Uses a combination of hostname and MAC address to generate a SHA256 hash,
+    ensuring the same machine always generates the same ID.
+
+    Returns:
+        str: 16-character unique client identifier
+    """
+    # Get hostname
+    hostname = socket.gethostname()
+
+    # Get MAC address (as integer)
+    mac = uuid.getnode()
+
+    # Combine machine characteristics
+    identifier = f"{hostname}:{mac}"
+
+    # Generate SHA256 hash and take first 16 characters
+    hash_value = hashlib.sha256(identifier.encode()).hexdigest()[:16]
+
+    return hash_value
+
+
+def get_machine_metadata() -> Dict[str, str]:
+    """
+    Get current machine metadata information for sending to server
+
+    Returns:
+        dict: Dictionary containing detailed machine information
+    """
+    metadata = {}
+
+    try:
+        # Get machine name
+        metadata["hostname"] = socket.gethostname()
+    except Exception:
+        metadata["hostname"] = "unknown"
+
+    try:
+        # Get MAC address
+        mac = uuid.getnode()
+        mac_address = ":".join(["{:02x}".format((mac >> elements) & 0xFF) for elements in range(0, 48, 8)][::-1])
+        metadata["mac_address"] = mac_address
+    except Exception:
+        pass
+
+    try:
+        # Get operating system information
+        metadata["os"] = platform.system()  # Windows, Linux, Darwin
+        metadata["os_version"] = platform.version()
+        metadata["os_release"] = platform.release()
+    except Exception:
+        pass
+
+    try:
+        # Get machine architecture
+        metadata["architecture"] = platform.machine()  # x86_64, arm64, etc.
+    except Exception:
+        pass
+
+    try:
+        # Get Python version
+        metadata["python_version"] = platform.python_version()
+    except Exception:
+        pass
+
+    try:
+        # Get processor information
+        metadata["processor"] = platform.processor()
+    except Exception:
+        pass
+
+    try:
+        # Get platform information
+        metadata["platform"] = platform.platform()
+    except Exception:
+        pass
+
+    return metadata

castrel_proxy/core/config.py

@@ -0,0 +1,158 @@
+"""
+Configuration File Management Module
+
+Handles reading, writing, and validating the ~/.castrel/config.yaml configuration file
+"""
+
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+class ConfigError(Exception):
+    """Configuration-related errors"""
+
+    pass
+
+
+class Config:
+    """Configuration management class"""
+
+    def __init__(self, config_dir: Optional[Path] = None):
+        """
+        Initialize configuration manager
+
+        Args:
+            config_dir: Configuration directory path, defaults to ~/.castrel
+        """
+        if config_dir is None:
+            self.config_dir = Path.home() / ".castrel"
+        else:
+            self.config_dir = Path(config_dir)
+
+        self.config_file = self.config_dir / "config.yaml"
+
+    def _ensure_config_dir(self):
+        """Ensure configuration directory exists"""
+        try:
+            self.config_dir.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            raise ConfigError(f"Failed to create config directory {self.config_dir}: {e}")
+
+    def save(self, server_url: str, verification_code: str, client_id: str, workspace_id: str) -> None:
+        """
+        Save configuration to file
+
+        Args:
+            server_url: Server URL
+            verification_code: Verification code
+            client_id: Client unique identifier
+            workspace_id: Workspace ID
+
+        Raises:
+            ConfigError: Raised when saving configuration fails
+        """
+        self._ensure_config_dir()
+
+        config_data = {
+            "server_url": server_url,
+            "verification_code": verification_code,
+            "client_id": client_id,
+            "workspace_id": workspace_id,
+            "paired_at": datetime.utcnow().isoformat() + "Z",
+        }
+
+        try:
+            with open(self.config_file, "w", encoding="utf-8") as f:
+                yaml.safe_dump(config_data, f, default_flow_style=False, allow_unicode=True)
+        except Exception as e:
+            raise ConfigError(f"Failed to save configuration: {e}")
+
+    def load(self) -> dict:
+        """
+        Load configuration from file
+
+        Returns:
+            dict: Configuration dictionary
+
+        Raises:
+            ConfigError: Raised when configuration file doesn't exist or loading fails
+        """
+        if not self.config_file.exists():
+            raise ConfigError("Configuration file does not exist. Please pair first using 'pair' command")
+
+        try:
+            with open(self.config_file, "r", encoding="utf-8") as f:
+                config_data = yaml.safe_load(f)
+
+            if not config_data:
+                raise ConfigError("Configuration file is empty")
+
+            # Validate required fields
+            required_fields = ["server_url", "verification_code", "client_id", "workspace_id"]
+            for field in required_fields:
+                if field not in config_data:
+                    raise ConfigError(f"Configuration file missing required field: {field}")
+
+            return config_data
+
+        except yaml.YAMLError as e:
+            raise ConfigError(f"Configuration file format error: {e}")
+        except Exception as e:
+            raise ConfigError(f"Failed to load configuration: {e}")
+
+    def exists(self) -> bool:
+        """
+        Check if configuration file exists
+
+        Returns:
+            bool: True if configuration file exists, False otherwise
+        """
+        return self.config_file.exists()
+
+    def delete(self) -> None:
+        """
+        Delete configuration file
+
+        Raises:
+            ConfigError: Raised when deletion fails
+        """
+        if not self.config_file.exists():
+            raise ConfigError("Configuration file does not exist")
+
+        try:
+            self.config_file.unlink()
+        except Exception as e:
+            raise ConfigError(f"Failed to delete configuration file: {e}")
+
+    def get_server_url(self) -> str:
+        """Get server URL"""
+        return self.load()["server_url"]
+
+    def get_verification_code(self) -> str:
+        """Get verification code"""
+        return self.load()["verification_code"]
+
+    def get_client_id(self) -> str:
+        """Get client ID"""
+        return self.load()["client_id"]
+
+    def get_paired_at(self) -> Optional[str]:
+        """Get pairing time"""
+        config = self.load()
+        return config.get("paired_at")
+
+    def get_workspace_id(self) -> str:
+        """Get workspace ID"""
+        return self.load()["workspace_id"]
+
+
+# Global configuration instance
+_config = Config()
+
+
+def get_config() -> Config:
+    """Get global configuration instance"""
+    return _config

castrel_proxy/core/daemon.py

@@ -0,0 +1,206 @@
+"""
+Daemon Process Management Module
+
+Handles background process management, PID files, and logging
+"""
+
+import atexit
+import logging
+import os
+import signal
+import sys
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class DaemonManager:
+    """Daemon process manager"""
+
+    def __init__(self, pid_file: Path, log_file: Path):
+        """
+        Initialize daemon manager
+
+        Args:
+            pid_file: PID file path
+            log_file: Log file path
+        """
+        self.pid_file = pid_file
+        self.log_file = log_file
+
+    def daemonize(self):
+        """
+        Daemonize the current process (Unix double-fork)
+
+        Raises:
+            OSError: If forking fails
+        """
+        # Check if already running
+        if self.is_running():
+            pid = self.get_pid()
+            raise RuntimeError(f"Daemon already running with PID {pid}")
+
+        # Ensure parent directories exist
+        self.pid_file.parent.mkdir(parents=True, exist_ok=True)
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # First fork
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # Parent process exits
+                sys.exit(0)
+        except OSError as e:
+            logger.error(f"First fork failed: {e}")
+            sys.exit(1)
+
+        # Decouple from parent environment
+        os.chdir("/")
+        os.setsid()
+        os.umask(0)
+
+        # Second fork
+        try:
+            pid = os.fork()
+            if pid > 0:
+                # Parent process exits
+                sys.exit(0)
+        except OSError as e:
+            logger.error(f"Second fork failed: {e}")
+            sys.exit(1)
+
+        # Redirect standard file descriptors
+        sys.stdout.flush()
+        sys.stderr.flush()
+
+        # Open log file
+        log_fd = os.open(str(self.log_file), os.O_CREAT | os.O_WRONLY | os.O_APPEND, 0o644)
+
+        # Redirect stdin to /dev/null
+        with open(os.devnull, "r") as devnull:
+            os.dup2(devnull.fileno(), sys.stdin.fileno())
+
+        # Redirect stdout and stderr to log file
+        os.dup2(log_fd, sys.stdout.fileno())
+        os.dup2(log_fd, sys.stderr.fileno())
+
+        os.close(log_fd)
+
+        # Write PID file
+        self._write_pid()
+
+        # Register cleanup on exit
+        atexit.register(self._cleanup)
+
+        # Handle termination signals
+        signal.signal(signal.SIGTERM, self._signal_handler)
+        signal.signal(signal.SIGINT, self._signal_handler)
+
+    def _write_pid(self):
+        """Write current process PID to file"""
+        pid = os.getpid()
+        with open(self.pid_file, "w") as f:
+            f.write(str(pid))
+        logger.info(f"Daemon started with PID {pid}")
+
+    def _cleanup(self):
+        """Cleanup PID file on exit"""
+        if self.pid_file.exists():
+            self.pid_file.unlink()
+            logger.info("Daemon stopped, PID file removed")
+
+    def _signal_handler(self, signum, frame):
+        """Handle termination signals"""
+        logger.info(f"Received signal {signum}, shutting down...")
+        sys.exit(0)
+
+    def get_pid(self) -> Optional[int]:
+        """
+        Get PID from PID file
+
+        Returns:
+            Optional[int]: PID if file exists and is valid, None otherwise
+        """
+        if not self.pid_file.exists():
+            return None
+
+        try:
+            with open(self.pid_file, "r") as f:
+                pid = int(f.read().strip())
+            return pid
+        except (ValueError, IOError):
+            return None
+
+    def is_running(self) -> bool:
+        """
+        Check if daemon process is running
+
+        Returns:
+            bool: True if running, False otherwise
+        """
+        pid = self.get_pid()
+        if pid is None:
+            return False
+
+        try:
+            # Check if process exists (send signal 0)
+            os.kill(pid, 0)
+            return True
+        except OSError:
+            # Process doesn't exist, clean up stale PID file
+            self.pid_file.unlink()
+            return False
+
+    def stop(self) -> bool:
+        """
+        Stop daemon process
+
+        Returns:
+            bool: True if stopped successfully, False if not running
+        """
+        pid = self.get_pid()
+        if pid is None:
+            return False
+
+        if not self.is_running():
+            # Clean up stale PID file
+            if self.pid_file.exists():
+                self.pid_file.unlink()
+            return False
+
+        try:
+            # Send SIGTERM to gracefully terminate
+            os.kill(pid, signal.SIGTERM)
+
+            # Wait for process to exit (with timeout)
+            import time
+
+            for _ in range(50):  # Wait up to 5 seconds
+                time.sleep(0.1)
+                if not self.is_running():
+                    return True
+
+            # If still running, force kill
+            if self.is_running():
+                os.kill(pid, signal.SIGKILL)
+                time.sleep(0.5)
+
+            return True
+        except OSError as e:
+            logger.error(f"Failed to stop daemon: {e}")
+            return False
+
+
+def get_daemon_manager() -> DaemonManager:
+    """
+    Get daemon manager instance
+
+    Returns:
+        DaemonManager: Daemon manager with default paths
+    """
+    config_dir = Path.home() / ".castrel"
+    pid_file = config_dir / "castrel-proxy.pid"
+    log_file = config_dir / "castrel-proxy.log"
+
+    return DaemonManager(pid_file, log_file)

castrel_proxy/core/executor.py

@@ -0,0 +1,166 @@
+"""
+Command Executor Module
+
+Responsible for executing shell commands and returning results
+"""
+
+import asyncio
+import os
+from typing import Dict, Optional
+
+
+class ExecutionResult:
+    """Command execution result"""
+
+    def __init__(self, exit_code: int, stdout: str, stderr: str, execution_time: float):
+        self.exit_code = exit_code
+        self.stdout = stdout
+        self.stderr = stderr
+        self.execution_time = execution_time
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary format"""
+        return {
+            "exit_code": self.exit_code,
+            "stdout": self.stdout,
+            "stderr": self.stderr,
+            "execution_time": self.execution_time,
+        }
+
+
+class CommandExecutor:
+    """Command executor"""
+
+    def __init__(self, session_id: str, working_dir: Optional[str] = None, timeout: float = 300.0):
+        """
+        Initialize command executor
+
+        Args:
+            session_id: Chat session ID (required)
+            working_dir: Working directory, if None uses ~/.castrel/${session_id}/ as default
+            timeout: Command execution timeout (seconds)
+        """
+        self.session_id = session_id
+
+        # Set session directory
+        home_dir = os.path.expanduser("~")
+        self.session_dir = os.path.join(home_dir, ".castrel", session_id)
+
+        # Create session directory
+        os.makedirs(self.session_dir, exist_ok=True)
+
+        # Set working directory (use session directory if not specified)
+        self.working_dir = working_dir if working_dir else self.session_dir
+        self.timeout = timeout
+
+        # Log file path
+        self.log_file = os.path.join(self.session_dir, "terminal.log")
+
+    async def execute(self, command: str, cwd: Optional[str] = None) -> ExecutionResult:
+        """
+        Execute shell command asynchronously
+
+        Args:
+            command: Command to execute
+            cwd: Working directory (override mode), if specified temporarily uses this directory,
+                 otherwise uses default working directory
+
+        Returns:
+            ExecutionResult: Command execution result
+        """
+        import time
+
+        start_time = time.time()
+
+        # Determine actual working directory to use
+        actual_cwd = cwd if cwd else self.working_dir
+
+        try:
+            # Expand ~ and environment variables in path
+            working_dir = os.path.expanduser(os.path.expandvars(actual_cwd))
+
+            # Create subprocess to execute command
+            # Set stdin to DEVNULL to prevent command from waiting for input and hanging
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdin=asyncio.subprocess.DEVNULL,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=working_dir,
+                env=os.environ.copy(),
+            )
+
+            # Wait for command to complete (with timeout)
+            try:
+                stdout_bytes, stderr_bytes = await asyncio.wait_for(process.communicate(), timeout=self.timeout)
+            except asyncio.TimeoutError:
+                # Timeout, terminate process
+                process.kill()
+                await process.wait()
+                execution_time = time.time() - start_time
+                result = ExecutionResult(
+                    exit_code=-1,
+                    stdout="",
+                    stderr=f"Command execution timeout (exceeded {self.timeout} seconds)",
+                    execution_time=execution_time,
+                )
+                # Log result
+                self._log_command(command, working_dir, result)
+                return result
+
+            # Decode output
+            stdout = stdout_bytes.decode("utf-8", errors="replace")
+            stderr = stderr_bytes.decode("utf-8", errors="replace")
+            exit_code = process.returncode
+
+            execution_time = time.time() - start_time
+
+            result = ExecutionResult(exit_code=exit_code, stdout=stdout, stderr=stderr, execution_time=execution_time)
+
+            # Log result
+            self._log_command(command, working_dir, result)
+
+            return result
+
+        except Exception as e:
+            execution_time = time.time() - start_time
+            result = ExecutionResult(
+                exit_code=-2, stdout="", stderr=f"Command execution exception: {str(e)}", execution_time=execution_time
+            )
+            # Log result
+            self._log_command(command, actual_cwd, result)
+            return result
+
+    def _log_command(self, command: str, cwd: str, result: ExecutionResult):
+        """
+        Log command execution to terminal.log
+
+        Args:
+            command: Executed command
+            cwd: Working directory
+            result: Execution result
+        """
+        from datetime import datetime
+
+        try:
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+            log_entry = f"""[{timestamp}] COMMAND: {command}
+  CWD: {cwd}
+  EXIT_CODE: {result.exit_code}
+  DURATION: {result.execution_time:.2f}s
+  STDOUT:
+    {result.stdout if result.stdout else "(empty)"}
+  STDERR:
+    {result.stderr if result.stderr else "(empty)"}
+---
+
+"""
+
+            # Append to log file
+            with open(self.log_file, "a", encoding="utf-8") as f:
+                f.write(log_entry)
+
+        except Exception as e:
+            # Logging failure should not affect command execution
+            print(f"Failed to log command: {e}")

castrel_proxy/data/__init__.py

@@ -0,0 +1 @@
+"""Data files for Castrel Bridge Proxy"""