shellmate-cli 3.0.0__py3-none-any.whl

shellmate/daemon/session.py

@@ -0,0 +1,170 @@
+import os
+import json
+import time
+import platform
+import tempfile
+from pathlib import Path
+from shellmate.config.paths import get_session_dir
+from shellmate.cli.version import VERSION
+
+
+def _session_file() -> Path:
+    """Resolve session.json path at call time (honors LOCALAPPDATA/XDG overrides)."""
+    return get_session_dir() / "session.json"
+
+
+# Kept for callers that import SESSION_FILE; prefer _session_file() for correctness.
+SESSION_FILE = get_session_dir() / "session.json"
+
+
+def get_session_dir_path() -> Path:
+    return get_session_dir()
+
+
+def create_session(pid: int, cwd: str, ipc_address: str) -> dict:
+    session_dir = get_session_dir()
+    session_dir.mkdir(parents=True, exist_ok=True)
+
+    if platform.system() != "Windows":
+        try:
+            session_dir.chmod(0o700)
+        except OSError:
+            pass
+
+    session = {
+        "pid": pid,
+        "cwd": cwd,
+        "created": time.time(),
+        "owner": get_owner_identity(),
+        "ipc_address": ipc_address,
+        "version": VERSION,
+    }
+
+    write_session_atomic(session)
+    return session
+
+
+def get_owner_identity() -> str:
+    if platform.system() == "Windows":
+        return os.environ.get("USERNAME", "unknown")
+    else:
+        import pwd
+        return pwd.getpwuid(os.getuid()).pw_name
+
+
+def write_session_atomic(session: dict) -> None:
+    session_file = _session_file()
+    temp_file = session_file.with_suffix(".tmp")
+    try:
+        with open(temp_file, "w") as f:
+            json.dump(session, f)
+        if platform.system() != "Windows":
+            os.chmod(temp_file, 0o600)
+        temp_file.replace(session_file)
+    except Exception:
+        if temp_file.exists():
+            temp_file.unlink(missing_ok=True)
+        raise
+
+
+def read_session() -> dict:
+    session_file = _session_file()
+    if not session_file.exists():
+        return None
+    try:
+        with open(session_file, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def remove_session() -> bool:
+    """Remove session directory and all v3 files."""
+    try:
+        session_dir = get_session_dir()
+        if session_dir.exists():
+            for file in session_dir.glob("*"):
+                file.unlink(missing_ok=True)
+            session_dir.rmdir()
+        return True
+    except OSError:
+        return False
+
+
+def get_command_history_file() -> Path:
+    """Get path to command history JSONL file."""
+    session_dir = get_session_dir()
+    session_dir.mkdir(parents=True, exist_ok=True)
+    return session_dir / "command_history.jsonl"
+
+
+def get_environment_cache_file() -> Path:
+    """Get path to environment detection cache."""
+    session_dir = get_session_dir()
+    session_dir.mkdir(parents=True, exist_ok=True)
+    cache_file = session_dir / "environment_cache.json"
+    if platform.system() != "Windows":
+        try:
+            if cache_file.exists():
+                cache_file.chmod(0o600)
+        except OSError:
+            pass
+    return cache_file
+
+
+def get_query_cache_file() -> Path:
+    """Get path to query response cache."""
+    session_dir = get_session_dir()
+    session_dir.mkdir(parents=True, exist_ok=True)
+    cache_file = session_dir / "query_cache.json"
+    if platform.system() != "Windows":
+        try:
+            if cache_file.exists():
+                cache_file.chmod(0o600)
+        except OSError:
+            pass
+    return cache_file
+
+
+def is_session_stale(session: dict) -> bool:
+    if not session:
+        return True
+    pid = session.get("pid")
+    if not pid:
+        return True
+    return not is_process_alive(pid)
+
+
+def is_process_alive(pid: int) -> bool:
+    if platform.system() == "Windows":
+        try:
+            import subprocess
+            result = subprocess.run(
+                ["tasklist", "/FI", f"PID eq {pid}"],
+                capture_output=True, text=True, timeout=5
+            )
+            return str(pid) in result.stdout
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            return False
+    else:
+        try:
+            os.kill(pid, 0)
+            return True
+        except OSError:
+            return False
+
+
+def cleanup_stale_sessions() -> int:
+    session = read_session()
+    if session and is_session_stale(session):
+        remove_session()
+        return 1
+    return 0
+
+
+def validate_session_ownership(session: dict) -> bool:
+    if not session:
+        return False
+    current_owner = get_owner_identity()
+    session_owner = session.get("owner")
+    return current_owner == session_owner

shellmate/daemon/startup_ui.py

@@ -0,0 +1,43 @@
+"""Startup UI — delegates to enable LiveScene (Claude Code–quiet morph)."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+from shellmate.ipc.client import ShellMateClient
+from shellmate.ui.runtime.console_factory import ConsoleFactory
+from shellmate.ui.runtime.motion_policy import motion_from_env
+from shellmate.ui.scenes.enable import run_enable_scene
+
+
+def run_startup_ui(timeout: int = 30, *, no_color: bool = False) -> bool:
+    """Poll daemon status and run the enable scene. Returns True if ready."""
+    client = ShellMateClient()
+    factory = ConsoleFactory(no_color=no_color)
+    console = factory.create()
+    plain = factory.is_plain()
+
+    def poll() -> tuple[Optional[list[str]], Optional[str]]:
+        try:
+            result = asyncio.run(client.send_command("/status", timeout=2.0))
+        except Exception:
+            return None, None
+        if not result or result.get("status") != "ok":
+            return None, None
+        data = result.get("data") or {}
+        completed = data.get("startup_stages_completed")
+        current = data.get("startup_stage")
+        if completed is not None and not isinstance(completed, list):
+            completed = None
+        return completed, current
+
+    return run_enable_scene(
+        poll=poll,
+        console=console,
+        plain=plain,
+        ascii_safe=plain,
+        timeout=float(timeout),
+        policy=motion_from_env(plain=plain),
+        poll_interval=0.12,
+    )

shellmate/environment/detector.py

@@ -0,0 +1,130 @@
+import os
+import platform
+import re
+
+SHELL_MAPPING = {
+    "bash": "bash",
+    "zsh": "zsh",
+    "fish": "fish",
+    "powershell": "powershell",
+    "pwsh": "powershell",
+    "cmd": "cmd",
+    "nu": "nushell",
+}
+
+
+def detect_os():
+    system = platform.system().lower()
+    if system == "linux":
+        return "linux"
+    elif system == "windows":
+        return "windows"
+    elif system == "darwin":
+        return "macos"
+    return system
+
+
+def detect_shell():
+    shell_env = os.environ.get("SHELL", "")
+    if shell_env:
+        shell_name = os.path.basename(shell_env).lower()
+        for key, value in SHELL_MAPPING.items():
+            if key in shell_name:
+                return value
+
+    # Prefer parent process name (accurate under PowerShell/pwsh/bash)
+    try:
+        import psutil
+        parent_pid = os.getppid()
+        parent_proc = psutil.Process(parent_pid)
+        parent_name = parent_proc.name().lower()
+        for key, value in SHELL_MAPPING.items():
+            if key in parent_name:
+                return value
+    except ImportError:
+        pass
+    except Exception:
+        pass
+
+    if platform.system() == "Windows":
+        # PSModulePath is set in PowerShell sessions; COMSPEC is almost always
+        # cmd.exe even when the user is in pwsh — so check PS first.
+        ps_module_path = os.environ.get("PSModulePath", "")
+        if ps_module_path:
+            return "powershell"
+        comspec = os.environ.get("COMSPEC", "")
+        if "cmd" in comspec.lower():
+            return "cmd"
+        return "powershell"
+
+    return "unknown"
+
+
+def detect_environment_type():
+    if platform.system() == "Windows":
+        wsl_distro = os.environ.get("WSL_DISTRO_NAME")
+        if wsl_distro:
+            return "wsl"
+        return "native"
+
+    if not platform.system() == "Linux":
+        return "native"
+
+    if os.environ.get("WSL_DISTRO_NAME"):
+        return "wsl"
+
+    try:
+        with open("/proc/version", "r") as f:
+            version = f.read().lower()
+            if "microsoft" in version or "wsl" in version:
+                return "wsl"
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    container_markers = [
+        "/.dockerenv",
+        "/run/.containerenv",
+    ]
+    for marker in container_markers:
+        if os.path.exists(marker):
+            return "container"
+
+    try:
+        with open("/proc/1/cgroup", "r") as f:
+            content = f.read()
+            if re.search(r"docker|kubepods|garden", content, re.IGNORECASE):
+                return "container"
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    ssh_vars = ["SSH_CLIENT", "SSH_TTY", "SSH_CONNECTION"]
+    for var in ssh_vars:
+        if os.environ.get(var):
+            return "ssh"
+
+    return "native"
+
+
+def detect_terminal():
+    term_program = os.environ.get("TERM_PROGRAM", "")
+    if term_program:
+        return term_program
+
+    term = os.environ.get("TERM", "")
+    if term and term != "dumb":
+        return term
+
+    wt_session = os.environ.get("WT_SESSION", "")
+    if wt_session:
+        return "Windows Terminal"
+
+    return "unknown"
+
+
+def detect_environment():
+    return {
+        "os": detect_os(),
+        "shell": detect_shell(),
+        "environment": detect_environment_type(),
+        "terminal": detect_terminal(),
+    }

shellmate/ipc/client.py

@@ -0,0 +1,210 @@
+import asyncio
+import json
+import uuid
+import threading
+from shellmate.config.defaults import get_default_config
+
+
+class DebouncedClient:
+    """Debounced API caller for autocomplete mode (300ms delay)"""
+    
+    def __init__(self, delay_ms=300):
+        self.delay = delay_ms / 1000.0
+        self.timer = None
+        self.callback = None
+    
+    def debounce(self, callback, *args, **kwargs):
+        """Reset timer on each call, execute only after delay"""
+        if self.timer:
+            self.timer.cancel()
+        
+        self.timer = threading.Timer(
+            self.delay,
+            lambda: callback(*args, **kwargs)
+        )
+        self.timer.start()
+    
+    def cancel(self):
+        """Cancel pending debounced call"""
+        if self.timer:
+            self.timer.cancel()
+
+# Global instance for ble.sh plugin to use
+_debounced_client = DebouncedClient(delay_ms=300)
+
+
+class ShellMateClient:
+    def __init__(self):
+        self.config = get_default_config()
+
+    async def send_command(self, command, user_queries=None, overrides=None, directives=None, timeout=60.0):
+        cfg = self.config["daemon"]
+        host = cfg["host"]
+        port = cfg["port"]
+
+        try:
+            reader, writer = await asyncio.wait_for(
+                asyncio.open_connection(host, port),
+                timeout=5.0,
+            )
+
+            request_id = str(uuid.uuid4())
+            message = json.dumps({
+                "command": command,
+                "request_id": request_id,
+                "user_queries": user_queries or [],
+                "overrides": overrides or {},
+                "directives": directives or [],
+            })
+
+            writer.write(message.encode("utf-8"))
+            await writer.drain()
+
+            data = await asyncio.wait_for(
+                reader.read(1024 * 1024),
+                timeout=timeout,
+            )
+
+            writer.close()
+            await writer.wait_closed()
+            return json.loads(data.decode("utf-8"))
+
+        except asyncio.TimeoutError:
+            return {"status": "error", "error": "Connection timed out. Is the daemon running?"}
+        except ConnectionRefusedError:
+            return {"status": "error", "error": "Connection refused. Run 'sm enable' first."}
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+
+    async def send_context_gatherer(self, command, timeout=60.0):
+        cfg = self.config["daemon"]
+        host = cfg["host"]
+        port = cfg["port"]
+
+        try:
+            reader, writer = await asyncio.wait_for(
+                asyncio.open_connection(host, port),
+                timeout=5.0,
+            )
+
+            request_id = str(uuid.uuid4())
+            message = json.dumps({
+                "command": "/context-gatherer",
+                "request_id": request_id,
+                "data": {"command": command}
+            })
+
+            writer.write(message.encode("utf-8"))
+            await writer.drain()
+
+            data = await asyncio.wait_for(
+                reader.read(1024 * 1024),
+                timeout=timeout,
+            )
+
+            writer.close()
+            await writer.wait_closed()
+            return json.loads(data.decode("utf-8"))
+
+        except asyncio.TimeoutError:
+            return {"status": "error", "error": "Connection timed out. Is the daemon running?"}
+        except ConnectionRefusedError:
+            return {"status": "error", "error": "Connection refused. Run 'sm enable' first."}
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+
+    async def send_command_partial(self, partial, timeout=5.0):
+        """Fast partial analysis for autocomplete"""
+        cfg = self.config["daemon"]
+        host, port = cfg["host"], cfg["port"]
+        
+        try:
+            reader, writer = await asyncio.wait_for(
+                asyncio.open_connection(host, port), timeout=2.0
+            )
+            
+            message = json.dumps({
+                "command": "/analyze-partial",
+                "request_id": str(uuid.uuid4()),
+                "partial": partial
+            })
+            
+            writer.write(message.encode("utf-8"))
+            await writer.drain()
+            
+            data = await asyncio.wait_for(reader.read(1024*1024), timeout=timeout)
+            writer.close()
+            await writer.wait_closed()
+            return json.loads(data.decode("utf-8"))
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+
+
+def analyze_command(command, user_queries=None, overrides=None, directives=None):
+    client = ShellMateClient()
+    try:
+        result = asyncio.run(client.send_command(command, user_queries=user_queries, overrides=overrides, directives=directives))
+        return result
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(client.send_command(command, user_queries=user_queries, overrides=overrides, directives=directives))
+            return result
+        finally:
+            loop.close()
+
+
+def send_status():
+    client = ShellMateClient()
+    try:
+        result = asyncio.run(client.send_command("/status"))
+        return result
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(client.send_command("/status"))
+            return result
+        finally:
+            loop.close()
+
+
+def send_context_gatherer(command):
+    client = ShellMateClient()
+    try:
+        result = asyncio.run(client.send_context_gatherer(command))
+        return result
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            result = loop.run_until_complete(client.send_context_gatherer(command))
+            return result
+        finally:
+            loop.close()
+
+
+
+def analyze_partial_debounced(partial_command, callback):
+    """
+    Analyze partial command with 300ms debounce.
+    callback(result) is called when API responds.
+    """
+    def _do_analyze():
+        try:
+            client = ShellMateClient()
+            result = asyncio.run(client.send_command_partial(partial_command))
+            if result.get("status") == "error":
+                # Silent fallback: no annotation shown
+                callback({"annotation": "", "severity": "SAFE"})
+            else:
+                callback(result)
+        except (ConnectionRefusedError, asyncio.TimeoutError):
+            # Daemon down: silent fallback (instant tier still works)
+            callback({"annotation": "", "severity": "SAFE"})
+        except Exception as e:
+            # Any other error: silent fallback
+            callback({"annotation": "", "severity": "SAFE"})
+    
+    _debounced_client.debounce(_do_analyze)