ptn 0.3.2__py3-none-any.whl → 0.4.6__py3-none-any.whl

porterminal/cli/display.py

@@ -58,6 +58,14 @@ def get_caution() -> str:
     return CAUTION_DEFAULT
 
 
+def _apply_gradient(lines: list[str], colors: list[str]) -> list[str]:
+    """Apply color gradient to text lines."""
+    return [
+        f"[{colors[min(i, len(colors) - 1)]}]{line}[/{colors[min(i, len(colors) - 1)]}]"
+        for i, line in enumerate(lines)
+    ]
+
+
 def get_qr_code(url: str) -> str:
     """Generate QR code as ASCII string.
 
@@ -112,21 +120,15 @@ def display_startup_screen(
     else:
         status = "[yellow]●[/yellow] LOCAL MODE"
 
-    # Build logo with gradient
-    logo_lines = LOGO.strip().split("\n")
-    colors = ["bold bright_cyan", "bright_cyan", "cyan", "bright_blue", "blue"]
-    logo_colored = []
-    for i, line in enumerate(logo_lines):
-        color = colors[i] if i < len(colors) else colors[-1]
-        logo_colored.append(f"[{color}]{line}[/{color}]")
-
-    # Build tagline with gradient
-    tagline_lines = TAGLINE.split("\n")
-    tagline_colors = ["bright_magenta", "magenta"]
-    tagline_colored = []
-    for i, line in enumerate(tagline_lines):
-        color = tagline_colors[i] if i < len(tagline_colors) else tagline_colors[-1]
-        tagline_colored.append(f"[{color}]{line}[/{color}]")
+    # Build logo and tagline with gradients
+    logo_colored = _apply_gradient(
+        LOGO.strip().split("\n"),
+        ["bold bright_cyan", "bright_cyan", "cyan", "bright_blue", "blue"],
+    )
+    tagline_colored = _apply_gradient(
+        TAGLINE.split("\n"),
+        ["bright_magenta", "magenta"],
+    )
 
     # Left side content
     left_lines = [
@@ -136,7 +138,7 @@ def display_startup_screen(
         *tagline_colored,
         "",
         f"[bold yellow]{get_caution()}[/bold yellow]",
-        "[dim]Use -p for password protection if your screen is exposed[/dim]",
+        "[bright_red]Use -p for password protection if your screen is exposed[/bright_red]",
         status,
         f"[bold cyan]{url}[/bold cyan]",
     ]

porterminal/cli/script_discovery.py

@@ -0,0 +1,266 @@
+"""Auto-discover project scripts for config initialization."""
+
+import json
+import re
+import tomllib
+from pathlib import Path
+
+import yaml
+
+# Pattern for safe script names (alphanumeric, hyphens, underscores only)
+_SAFE_NAME = re.compile(r"^[a-zA-Z0-9_-]+$")
+
+# Maximum buttons to return from each discovery function
+_MAX_BUTTONS = 6
+
+
+def _is_safe_name(name: str) -> bool:
+    """Check if script name contains only safe characters."""
+    return bool(_SAFE_NAME.match(name)) and len(name) <= 50
+
+
+def _find_file(base: Path, filenames: list[str]) -> Path | None:
+    """Find the first existing file from a list of candidates."""
+    for filename in filenames:
+        path = base / filename
+        if path.exists():
+            return path
+    return None
+
+
+def _build_buttons(
+    tasks: dict,
+    priority: list[str],
+    command_prefix: str,
+    *,
+    priority_only: bool = False,
+) -> list[dict]:
+    """Build button configs from tasks dict with priority ordering.
+
+    Args:
+        tasks: Dict of task names to their definitions
+        priority: List of task names to prioritize
+        command_prefix: Command prefix (e.g., "deno task", "task", "just")
+        priority_only: If True, only include tasks from priority list
+    """
+    buttons = []
+    priority_set = set(priority)
+
+    # Add priority tasks first
+    for name in priority:
+        if name in tasks and _is_safe_name(name):
+            buttons.append({"label": name, "send": f"{command_prefix} {name}\r", "row": 2})
+
+    # Add remaining tasks (unless priority_only is set)
+    if not priority_only:
+        for name in tasks:
+            if name not in priority_set and _is_safe_name(name) and len(buttons) < _MAX_BUTTONS:
+                buttons.append({"label": name, "send": f"{command_prefix} {name}\r", "row": 2})
+
+    return buttons[:_MAX_BUTTONS]
+
+
+def discover_scripts(cwd: Path | None = None) -> list[dict]:
+    """Discover project scripts in current directory.
+
+    Returns list of button configs: [{"label": "build", "send": "npm run build\\r", "row": 2}]
+    Only includes scripts explicitly defined in project files.
+    """
+    base = cwd or Path.cwd()
+    buttons = []
+
+    # Check each project type (only those with explicit scripts)
+    # Order matters: first match wins for deduplication
+    buttons.extend(_discover_npm_scripts(base))  # Also handles Bun
+    buttons.extend(_discover_deno_tasks(base))
+    buttons.extend(_discover_python_scripts(base))
+    buttons.extend(_discover_makefile_targets(base))
+    buttons.extend(_discover_just_recipes(base))
+    buttons.extend(_discover_taskfile_tasks(base))
+
+    # Dedupe by label, keep first occurrence
+    unique: dict[str, dict] = {}
+    for btn in buttons:
+        unique.setdefault(btn["label"], btn)
+    return list(unique.values())
+
+
+def _discover_npm_scripts(base: Path) -> list[dict]:
+    """Extract scripts from package.json.
+
+    Uses 'bun run' if bun.lockb exists, otherwise 'npm run'.
+    Only includes scripts from the priority list (build, dev, start, etc.).
+    """
+    pkg_file = base / "package.json"
+    if not pkg_file.exists():
+        return []
+
+    try:
+        data = json.loads(pkg_file.read_text(encoding="utf-8"))
+        scripts = data.get("scripts", {})
+
+        # Detect package manager: bun if bun.lockb exists
+        runner = "bun run" if (base / "bun.lockb").exists() else "npm run"
+        priority = ["build", "dev", "start", "test", "lint", "format", "watch"]
+
+        return _build_buttons(scripts, priority, runner, priority_only=True)
+    except Exception:
+        return []
+
+
+def _discover_python_scripts(base: Path) -> list[dict]:
+    """Extract scripts from pyproject.toml.
+
+    Checks [project.scripts] (PEP 621) first, then [tool.poetry.scripts].
+    Takes up to 4 from each source, deduplicates, and caps at 6 total.
+    """
+    toml_file = base / "pyproject.toml"
+    if not toml_file.exists():
+        return []
+
+    try:
+        data = tomllib.loads(toml_file.read_text(encoding="utf-8"))
+        buttons = []
+
+        # Check [project.scripts] (PEP 621) - take up to 4
+        project_scripts = data.get("project", {}).get("scripts", {})
+        for name in list(project_scripts.keys())[:4]:
+            if _is_safe_name(name):
+                buttons.append({"label": name, "send": f"{name}\r", "row": 2})
+
+        # Check [tool.poetry.scripts] - take up to 4, skip duplicates
+        existing_labels = {b["label"] for b in buttons}
+        poetry_scripts = data.get("tool", {}).get("poetry", {}).get("scripts", {})
+        for name in list(poetry_scripts.keys())[:4]:
+            if _is_safe_name(name) and name not in existing_labels:
+                buttons.append({"label": name, "send": f"{name}\r", "row": 2})
+
+        return buttons[:_MAX_BUTTONS]
+    except Exception:
+        return []
+
+
+def _discover_makefile_targets(base: Path) -> list[dict]:
+    """Extract targets from Makefile."""
+    makefile = base / "Makefile"
+    if not makefile.exists():
+        return []
+
+    try:
+        content = makefile.read_text(encoding="utf-8")
+        # Match target definitions: "target:" at start of line
+        # Regex excludes targets starting with . (internal targets like .PHONY)
+        pattern = r"^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:"
+        targets = re.findall(pattern, content, re.MULTILINE)
+
+        # Convert list to dict for _build_buttons compatibility
+        targets_dict = {t: True for t in targets}
+        priority = ["build", "test", "run", "clean", "install", "dev", "lint", "all"]
+
+        return _build_buttons(targets_dict, priority, "make")
+    except Exception:
+        return []
+
+
+def _discover_deno_tasks(base: Path) -> list[dict]:
+    """Extract tasks from deno.json or deno.jsonc."""
+    deno_file = _find_file(base, ["deno.json", "deno.jsonc"])
+    if not deno_file:
+        return []
+
+    try:
+        content = deno_file.read_text(encoding="utf-8")
+        if deno_file.suffix == ".jsonc":
+            content = _strip_json_comments(content)
+
+        tasks = json.loads(content).get("tasks", {})
+        priority = ["build", "dev", "start", "test", "lint", "format", "check"]
+
+        return _build_buttons(tasks, priority, "deno task")
+    except Exception:
+        return []
+
+
+def _strip_json_comments(content: str) -> str:
+    """Strip comments from JSON content (for .jsonc files)."""
+    result = []
+    i = 0
+    in_string = False
+    escape_next = False
+
+    while i < len(content):
+        char = content[i]
+
+        if escape_next:
+            result.append(char)
+            escape_next = False
+            i += 1
+            continue
+
+        if char == "\\" and in_string:
+            result.append(char)
+            escape_next = True
+            i += 1
+            continue
+
+        if char == '"' and not escape_next:
+            in_string = not in_string
+            result.append(char)
+            i += 1
+            continue
+
+        if not in_string:
+            # Single-line comment
+            if content[i : i + 2] == "//":
+                while i < len(content) and content[i] != "\n":
+                    i += 1
+                continue
+            # Multi-line comment
+            if content[i : i + 2] == "/*":
+                i += 2
+                while i < len(content) - 1 and content[i : i + 2] != "*/":
+                    i += 1
+                i += 2
+                continue
+
+        result.append(char)
+        i += 1
+
+    return "".join(result)
+
+
+def _discover_just_recipes(base: Path) -> list[dict]:
+    """Extract recipes from justfile."""
+    justfile = _find_file(base, ["justfile", "Justfile", ".justfile"])
+    if not justfile:
+        return []
+
+    try:
+        content = justfile.read_text(encoding="utf-8")
+        # Match recipe definitions: "recipe:" or "recipe arg:" at start of line
+        # Exclude private recipes (starting with _) and recipes with @ prefix
+        pattern = r"^([a-zA-Z][a-zA-Z0-9_-]*)\s*(?:[^:]*)?:"
+        recipes = re.findall(pattern, content, re.MULTILINE)
+
+        # Convert list to dict for _build_buttons compatibility
+        recipes_dict = {r: True for r in recipes}
+        priority = ["build", "test", "run", "dev", "check", "lint", "fmt", "clean"]
+
+        return _build_buttons(recipes_dict, priority, "just")
+    except Exception:
+        return []
+
+
+def _discover_taskfile_tasks(base: Path) -> list[dict]:
+    """Extract tasks from Taskfile.yml."""
+    taskfile = _find_file(base, ["Taskfile.yml", "Taskfile.yaml", "taskfile.yml", "taskfile.yaml"])
+    if not taskfile:
+        return []
+
+    try:
+        tasks = yaml.safe_load(taskfile.read_text(encoding="utf-8")).get("tasks", {})
+        priority = ["build", "test", "run", "dev", "lint", "fmt", "clean", "default"]
+
+        return _build_buttons(tasks, priority, "task")
+    except Exception:
+        return []

porterminal/composition.py

@@ -14,8 +14,6 @@ from porterminal.application.services import (
 from porterminal.config import find_config_file
 from porterminal.container import Container
 from porterminal.domain import (
-    EnvironmentRules,
-    EnvironmentSanitizer,
     PTYPort,
     SessionLimitChecker,
     ShellCommand,
@@ -29,7 +27,7 @@ from porterminal.infrastructure.repositories import InMemorySessionRepository, I
 
 def create_pty_factory(
     cwd: str | None = None,
-) -> Callable[[ShellCommand, TerminalDimensions, dict[str, str], str | None], PTYPort]:
+) -> Callable[[ShellCommand, TerminalDimensions, str | None], PTYPort]:
     """Create a PTY factory function.
 
     This bridges the domain PTYPort interface with the existing
@@ -40,7 +38,6 @@ def create_pty_factory(
     def factory(
         shell: ShellCommand,
         dimensions: TerminalDimensions,
-        environment: dict[str, str],
         working_directory: str | None = None,
     ) -> PTYPort:
         # Use provided cwd or factory default
@@ -60,6 +57,7 @@ def create_pty_factory(
         )
 
         # Create manager (which implements PTY operations)
+        # Environment sanitization is handled internally by SecurePTYManager
         manager = SecurePTYManager(
             backend=backend,
             shell_config=legacy_shell,
@@ -68,8 +66,6 @@ def create_pty_factory(
             cwd=effective_cwd,
         )
 
-        # Spawn with environment (manager handles sanitization internally,
-        # but we pass our sanitized env to be safe)
         manager.spawn()
 
         return PTYManagerAdapter(manager, dimensions)
@@ -173,7 +169,6 @@ def create_container(
         repository=session_repository,
         pty_factory=pty_factory,
         limit_checker=SessionLimitChecker(),
-        environment_sanitizer=EnvironmentSanitizer(EnvironmentRules()),
         working_directory=cwd,
     )
 

porterminal/config.py

@@ -7,6 +7,7 @@ from pathlib import Path
 import yaml
 from pydantic import BaseModel, Field, field_validator
 
+from porterminal.domain.values import MAX_COLS, MAX_ROWS, MIN_COLS, MIN_ROWS
 from porterminal.infrastructure.config import ShellDetector
 
 
@@ -43,8 +44,8 @@ class TerminalConfig(BaseModel):
     """Terminal configuration."""
 
     default_shell: str = ""
-    cols: int = Field(default=120, ge=40, le=500)
-    rows: int = Field(default=30, ge=10, le=200)
+    cols: int = Field(default=120, ge=MIN_COLS, le=MAX_COLS)
+    rows: int = Field(default=30, ge=MIN_ROWS, le=MAX_ROWS)
     shells: list[ShellConfig] = Field(default_factory=list)
 
     def get_shell(self, shell_id: str) -> ShellConfig | None:
@@ -60,6 +61,7 @@ class ButtonConfig(BaseModel):
 
     label: str
     send: str | list[str | int] = ""  # string or list of strings/ints (ints = wait ms)
+    row: int = Field(default=1, ge=1, le=10)  # toolbar row (1-10)
 
 
 class CloudflareConfig(BaseModel):

porterminal/domain/__init__.py

@@ -1,6 +1,5 @@
 """Pure domain layer - no infrastructure dependencies."""
 
-# Value Objects
 # Entities
 from .entities import (
     CLEAR_SCREEN_SEQUENCE,
@@ -23,7 +22,6 @@ from .ports import (
 # Services
 from .services import (
     Clock,
-    EnvironmentSanitizer,
     SessionLimitChecker,
     SessionLimitConfig,
     SessionLimitResult,
@@ -33,13 +31,10 @@ from .services import (
     TokenBucketRateLimiter,
 )
 from .values import (
-    DEFAULT_BLOCKED_VARS,
-    DEFAULT_SAFE_VARS,
     MAX_COLS,
     MAX_ROWS,
     MIN_COLS,
     MIN_ROWS,
-    EnvironmentRules,
     RateLimitConfig,
     SessionId,
     ShellCommand,
@@ -60,9 +55,6 @@ __all__ = [
     "TabId",
     "ShellCommand",
     "RateLimitConfig",
-    "EnvironmentRules",
-    "DEFAULT_SAFE_VARS",
-    "DEFAULT_BLOCKED_VARS",
     # Entities
     "Session",
     "MAX_SESSIONS_PER_USER",
@@ -75,7 +67,6 @@ __all__ = [
     # Services
     "TokenBucketRateLimiter",
     "Clock",
-    "EnvironmentSanitizer",
     "SessionLimitChecker",
     "SessionLimitConfig",
     "SessionLimitResult",

porterminal/domain/entities/output_buffer.py

@@ -9,6 +9,11 @@ OUTPUT_BUFFER_MAX_BYTES = 1_000_000  # 1MB
 # Terminal escape sequence for clear screen (ED2)
 CLEAR_SCREEN_SEQUENCE = b"\x1b[2J"
 
+# Alternate screen buffer sequences (DEC Private Mode)
+# Used by vim, htop, less, tmux, etc.
+ALT_SCREEN_ENTER = (b"\x1b[?47h", b"\x1b[?1047h", b"\x1b[?1049h")
+ALT_SCREEN_EXIT = (b"\x1b[?47l", b"\x1b[?1047l", b"\x1b[?1049l")
+
 
 @dataclass
 class OutputBuffer:
@@ -16,12 +21,21 @@ class OutputBuffer:
 
     Pure domain logic for buffering terminal output.
     No async, no WebSocket - just data management.
+
+    Handles alternate screen buffer (used by vim, htop, less, etc.):
+    - On alt-screen enter: snapshots normal buffer, clears for alt content
+    - On alt-screen exit: restores normal buffer, discards alt content
     """
 
     max_bytes: int = OUTPUT_BUFFER_MAX_BYTES
     _buffer: deque[bytes] = field(default_factory=deque)
     _size: int = 0
 
+    # Alt-screen state
+    _in_alt_screen: bool = False
+    _normal_snapshot: deque[bytes] | None = None
+    _normal_snapshot_size: int = 0
+
     @property
     def size(self) -> int:
         """Current buffer size in bytes."""
@@ -32,12 +46,53 @@ class OutputBuffer:
         """Check if buffer is empty."""
         return self._size == 0
 
+    @property
+    def in_alt_screen(self) -> bool:
+        """Check if currently in alternate screen mode."""
+        return self._in_alt_screen
+
+    def _enter_alt_screen(self) -> None:
+        """Handle alt-screen entry: snapshot normal buffer."""
+        if self._in_alt_screen:
+            return  # Already in alt-screen, ignore nested
+        self._in_alt_screen = True
+        self._normal_snapshot = self._buffer.copy()
+        self._normal_snapshot_size = self._size
+        self._clear_buffer()
+
+    def _exit_alt_screen(self) -> None:
+        """Handle alt-screen exit: restore normal buffer."""
+        if not self._in_alt_screen:
+            return  # Not in alt-screen, ignore
+        self._in_alt_screen = False
+        if self._normal_snapshot is not None:
+            self._buffer = self._normal_snapshot
+            self._size = self._normal_snapshot_size
+            self._normal_snapshot = None
+            self._normal_snapshot_size = 0
+
+    def _clear_buffer(self) -> None:
+        """Clear the buffer contents only."""
+        self._buffer.clear()
+        self._size = 0
+
     def add(self, data: bytes) -> None:
         """Add data to the buffer.
 
-        Handles clear screen detection and size limits.
+        Handles alt-screen transitions, clear screen detection, and size limits.
         When clear screen is detected, only keep content AFTER the last clear sequence.
         """
+        # Check alt-screen transitions FIRST
+        for pattern in ALT_SCREEN_EXIT:
+            if pattern in data:
+                self._exit_alt_screen()
+                break
+        else:
+            for pattern in ALT_SCREEN_ENTER:
+                if pattern in data:
+                    self._enter_alt_screen()
+                    return  # Don't buffer alt-screen enter data
+
         # Check for clear screen sequence
         if CLEAR_SCREEN_SEQUENCE in data:
             # Clear old buffer

porterminal/domain/entities/tab.py

@@ -13,6 +13,15 @@ TAB_NAME_MIN_LENGTH = 1
 TAB_NAME_MAX_LENGTH = 50
 
 
+def _validate_tab_name(name: str) -> None:
+    """Validate tab name length."""
+    if not (TAB_NAME_MIN_LENGTH <= len(name) <= TAB_NAME_MAX_LENGTH):
+        raise ValueError(
+            f"Tab name must be {TAB_NAME_MIN_LENGTH}-{TAB_NAME_MAX_LENGTH} "
+            f"characters, got {len(name)}"
+        )
+
+
 @dataclass
 class Tab:
     """Terminal tab entity.
@@ -35,11 +44,7 @@ class Tab:
     last_accessed: datetime
 
     def __post_init__(self) -> None:
-        if not (TAB_NAME_MIN_LENGTH <= len(self.name) <= TAB_NAME_MAX_LENGTH):
-            raise ValueError(
-                f"Tab name must be {TAB_NAME_MIN_LENGTH}-{TAB_NAME_MAX_LENGTH} "
-                f"characters, got {len(self.name)}"
-            )
+        _validate_tab_name(self.name)
 
     @property
     def tab_id(self) -> str:
@@ -52,11 +57,7 @@ class Tab:
 
     def rename(self, new_name: str) -> None:
         """Rename the tab with validation."""
-        if not (TAB_NAME_MIN_LENGTH <= len(new_name) <= TAB_NAME_MAX_LENGTH):
-            raise ValueError(
-                f"Tab name must be {TAB_NAME_MIN_LENGTH}-{TAB_NAME_MAX_LENGTH} "
-                f"characters, got {len(new_name)}"
-            )
+        _validate_tab_name(new_name)
         self.name = new_name
 
     def to_dict(self) -> dict:

porterminal/domain/services/__init__.py

@@ -1,6 +1,5 @@
 """Domain services - pure business logic operations."""
 
-from .environment_sanitizer import EnvironmentSanitizer
 from .rate_limiter import Clock, TokenBucketRateLimiter
 from .session_limits import SessionLimitChecker, SessionLimitConfig, SessionLimitResult
 from .tab_limits import TabLimitChecker, TabLimitConfig, TabLimitResult
@@ -8,7 +7,6 @@ from .tab_limits import TabLimitChecker, TabLimitConfig, TabLimitResult
 __all__ = [
     "TokenBucketRateLimiter",
     "Clock",
-    "EnvironmentSanitizer",
     "SessionLimitChecker",
     "SessionLimitConfig",
     "SessionLimitResult",

porterminal/domain/values/__init__.py

@@ -1,6 +1,5 @@
 """Domain value objects - immutable data structures."""
 
-from .environment_rules import DEFAULT_BLOCKED_VARS, DEFAULT_SAFE_VARS, EnvironmentRules
 from .rate_limit_config import RateLimitConfig
 from .session_id import SessionId
 from .shell_command import ShellCommand
@@ -19,7 +18,4 @@ __all__ = [
     "TabId",
     "ShellCommand",
     "RateLimitConfig",
-    "EnvironmentRules",
-    "DEFAULT_SAFE_VARS",
-    "DEFAULT_BLOCKED_VARS",
 ]

porterminal/domain/values/environment_rules.py

@@ -22,12 +22,15 @@ DEFAULT_SAFE_VARS: frozenset[str] = frozenset(
         "HOMEPATH",
         "LOCALAPPDATA",
         "APPDATA",
+        "PROGRAMDATA",
         "PROGRAMFILES",
         "PROGRAMFILES(X86)",
         "COMMONPROGRAMFILES",
         # System info
         "COMPUTERNAME",
         "USERNAME",
+        "USER",
+        "LOGNAME",
         "USERDOMAIN",
         "OS",
         "PROCESSOR_ARCHITECTURE",

porterminal/domain/values/rate_limit_config.py

@@ -2,9 +2,9 @@
 
 from dataclasses import dataclass
 
-# Default business rules
-DEFAULT_RATE = 100.0  # tokens per second
-DEFAULT_BURST = 500
+# Defaults: 1KB/s sustained, 16KB burst (allows reasonable paste operations)
+DEFAULT_RATE = 1000.0
+DEFAULT_BURST = 16384
 
 
 @dataclass(frozen=True, slots=True)