loki-mode 6.53.0 → 6.55.0

package/web-app/models.py

@@ -0,0 +1,140 @@
+"""Purple Lab database models.
+
+Provides SQLAlchemy models for multi-user cloud deployment.
+When no DATABASE_URL is configured, the system falls back to
+file-based storage (local development mode).
+"""
+import os
+import uuid
+from datetime import datetime
+
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Integer,
+    JSON,
+    String,
+    Text,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, relationship
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    email = Column(String(255), unique=True, nullable=False, index=True)
+    name = Column(String(255))
+    avatar_url = Column(String(500))
+    provider = Column(String(50))  # "github", "google", "email"
+    provider_id = Column(String(255))  # External provider user ID
+    password_hash = Column(String(255), nullable=True)  # For email/password auth
+    created_at = Column(DateTime, default=datetime.utcnow)
+    last_login = Column(DateTime)
+    is_active = Column(Boolean, default=True)
+
+    sessions = relationship("Session", back_populates="user")
+    projects = relationship("Project", back_populates="user")
+
+
+class Project(Base):
+    __tablename__ = "projects"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+    name = Column(String(255), nullable=False)
+    description = Column(Text)
+    project_dir = Column(String(500), nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    user = relationship("User", back_populates="projects")
+    sessions = relationship("Session", back_populates="project")
+
+
+class Session(Base):
+    __tablename__ = "sessions"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+    project_id = Column(UUID(as_uuid=True), ForeignKey("projects.id"), nullable=True)
+    prd_content = Column(Text)
+    provider = Column(String(50), default="claude")
+    mode = Column(String(50), default="standard")
+    status = Column(String(50), default="created")  # created, running, paused, completed, failed
+    started_at = Column(DateTime, default=datetime.utcnow)
+    ended_at = Column(DateTime, nullable=True)
+    metadata_json = Column(JSON, default=dict)
+
+    user = relationship("User", back_populates="sessions")
+    project = relationship("Project", back_populates="sessions")
+
+
+class Secret(Base):
+    __tablename__ = "secrets"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
+    key = Column(String(255), nullable=False)
+    encrypted_value = Column(Text, nullable=False)  # Fernet encrypted
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_log"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+    user_id = Column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
+    action = Column(String(100), nullable=False)  # "session.start", "file.save", etc.
+    resource_type = Column(String(50))  # "session", "file", "secret"
+    resource_id = Column(String(255))
+    details = Column(JSON, default=dict)
+    ip_address = Column(String(45))
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+# ---------------------------------------------------------------------------
+# Database connection state
+# ---------------------------------------------------------------------------
+
+DATABASE_URL: str | None = None
+engine = None
+async_session_factory: async_sessionmaker | None = None
+
+
+async def init_db(database_url: str | None = None) -> bool:
+    """Initialize database connection. Returns False if no URL configured (file-based fallback)."""
+    global DATABASE_URL, engine, async_session_factory
+
+    url = database_url or os.environ.get("DATABASE_URL")
+    if not url:
+        return False  # No database configured, use file-based fallback
+
+    DATABASE_URL = url
+    engine = create_async_engine(url, echo=False)
+    async_session_factory = async_sessionmaker(
+        engine, class_=AsyncSession, expire_on_commit=False
+    )
+
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+    return True
+
+
+async def get_db():
+    """Get database session. Yields None if no database configured."""
+    if async_session_factory is None:
+        yield None
+        return
+    async with async_session_factory() as session:
+        yield session

package/web-app/requirements.txt

@@ -0,0 +1,27 @@
+# Core -- required for server.py to start
+fastapi>=0.100.0
+uvicorn[standard]>=0.20.0
+pydantic>=2.0.0
+httpx>=0.24.0
+
+# Terminal -- PTY-based interactive terminal
+pexpect>=4.8.0
+
+# File watcher -- live file-change notifications via WebSocket
+watchdog>=3.0.0
+
+# Database (optional) -- only needed for multi-user cloud deployment.
+# Without DATABASE_URL set, the server uses file-based storage.
+sqlalchemy[asyncio]>=2.0.0
+asyncpg>=0.28.0
+aiosqlite>=0.19.0
+alembic>=1.12.0
+
+# Auth (optional) -- only needed when DATABASE_URL is configured.
+# Imports are guarded by try/except so the server starts without them.
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+
+# Encryption (optional) -- Fernet encryption for user secrets.
+# Needed only for the /api/secrets endpoints in cloud mode.
+cryptography>=41.0.0

package/web-app/server.py

@@ -482,6 +482,60 @@ class DevServerManager:
 
     def __init__(self) -> None:
         self.servers: Dict[str, dict] = {}
+        self._portless_available: Optional[bool] = None
+        self._portless_proxy_started = False
+
+    def _has_portless(self) -> bool:
+        """Check if portless CLI is installed (cached)."""
+        if self._portless_available is None:
+            try:
+                subprocess.run(
+                    ["portless", "--version"],
+                    capture_output=True, timeout=5,
+                )
+                self._portless_available = True
+            except (FileNotFoundError, subprocess.TimeoutExpired):
+                self._portless_available = False
+        return self._portless_available
+
+    def _portless_app_name(self, session_id: str) -> str:
+        """Generate a deterministic short app name from session_id."""
+        clean = re.sub(r"[^a-zA-Z0-9]", "", session_id)
+        return f"lab-{clean[:6].lower()}"
+
+    def _ensure_portless_proxy(self) -> bool:
+        """Start the portless proxy if not already running.
+
+        Returns True if the proxy is available, False otherwise.
+        """
+        if self._portless_proxy_started:
+            return True
+        # Check if port 1355 is already listening
+        import socket
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.settimeout(1)
+        try:
+            s.connect(("127.0.0.1", 1355))
+            s.close()
+            self._portless_proxy_started = True
+            return True
+        except (ConnectionRefusedError, OSError):
+            s.close()
+        # Try to start the proxy
+        try:
+            subprocess.Popen(
+                ["portless", "proxy", "start"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+            )
+            # Give it a moment to start
+            import time as _time
+            _time.sleep(1)
+            self._portless_proxy_started = True
+            return True
+        except (FileNotFoundError, OSError):
+            return False
 
     async def detect_dev_command(self, project_dir: str) -> Optional[dict]:
         """Detect the dev command from project files."""
@@ -557,7 +611,20 @@ class DevServerManager:
         if session_id in self.servers:
             await self.stop(session_id)
 
+        # Try to detect dev command -- check root first, then subdirectories
         detected = await self.detect_dev_command(project_dir)
+        actual_dir = project_dir
+        if not detected:
+            # Check immediate subdirectories for a project with package.json
+            root = Path(project_dir)
+            if root.is_dir():
+                for subdir in sorted(root.iterdir()):
+                    if subdir.is_dir() and not subdir.name.startswith('.'):
+                        sub_detected = await self.detect_dev_command(str(subdir))
+                        if sub_detected:
+                            detected = sub_detected
+                            actual_dir = str(subdir)
+                            break
         if not command and not detected:
             return {"status": "error", "message": "No dev command detected. Provide one explicitly."}
 
@@ -565,18 +632,39 @@ class DevServerManager:
         expected_port = detected["expected_port"] if detected else 3000
         framework = detected["framework"] if detected else "unknown"
 
+        # Auto-install dependencies if needed
+        actual_path = Path(actual_dir)
+        needs_npm = (actual_path / "package.json").exists() and not (actual_path / "node_modules").exists()
+        needs_pip = (actual_path / "requirements.txt").exists() and not (actual_path / "venv").exists()
+        if needs_npm:
+            # Prepend npm install to the command
+            cmd_str = f"npm install && {cmd_str}"
+        if needs_pip:
+            cmd_str = f"pip install -r requirements.txt && {cmd_str}"
+
+        # Check if portless is available and proxy is running
+        use_portless = False
+        portless_app_name = None
+        if self._has_portless() and self._ensure_portless_proxy():
+            portless_app_name = self._portless_app_name(session_id)
+            use_portless = True
+            # Wrap the command with portless
+            effective_cmd = f"portless {portless_app_name} {cmd_str}"
+        else:
+            effective_cmd = cmd_str
+
         build_env = {**os.environ}
         build_env.update(_load_secrets())
 
         try:
             proc = subprocess.Popen(
-                cmd_str,
+                effective_cmd,
                 shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.STDOUT,
                 stdin=subprocess.DEVNULL,
                 text=True,
-                cwd=project_dir,
+                cwd=actual_dir,
                 env=build_env,
                 **({"start_new_session": True} if sys.platform != "win32"
                    else {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}),
@@ -588,12 +676,15 @@ class DevServerManager:
             "process": proc,
             "port": None,
             "expected_port": expected_port,
-            "command": cmd_str,
+            "command": effective_cmd,
+            "original_command": cmd_str,
             "framework": framework,
             "status": "starting",
             "pid": proc.pid,
             "project_dir": project_dir,
             "output_lines": [],
+            "use_portless": use_portless,
+            "portless_app_name": portless_app_name,
         }
         self.servers[session_id] = server_info
 
@@ -612,16 +703,22 @@ class DevServerManager:
                     "output": info["output_lines"][-10:] if info["output_lines"] else [],
                 }
             if info["port"] is not None:
-                health_ok = await self._health_check(info["port"])
+                # For portless, also verify the portless proxy can reach the app
+                check_port = info["port"]
+                health_ok = await self._health_check(check_port)
                 if health_ok:
                     info["status"] = "running"
-                    return {
+                    result = {
                         "status": "running",
                         "port": info["port"],
-                        "command": cmd_str,
+                        "command": effective_cmd,
                         "pid": proc.pid,
                         "url": f"/proxy/{session_id}/",
                     }
+                    if use_portless and portless_app_name:
+                        result["portless_url"] = f"http://{portless_app_name}.localhost:1355/"
+                        result["port"] = 1355
+                    return result
 
         if proc.poll() is not None:
             server_info["status"] = "error"
@@ -635,24 +732,32 @@ class DevServerManager:
         if health_ok:
             server_info["port"] = expected_port
             server_info["status"] = "running"
-            return {
+            result = {
                 "status": "running",
                 "port": expected_port,
-                "command": cmd_str,
+                "command": effective_cmd,
                 "pid": proc.pid,
                 "url": f"/proxy/{session_id}/",
             }
+            if use_portless and portless_app_name:
+                result["portless_url"] = f"http://{portless_app_name}.localhost:1355/"
+                result["port"] = 1355
+            return result
 
         server_info["status"] = "starting"
         server_info["port"] = expected_port
-        return {
+        result = {
             "status": "starting",
             "message": "Server started but port not yet confirmed",
             "port": expected_port,
-            "command": cmd_str,
+            "command": effective_cmd,
             "pid": proc.pid,
             "url": f"/proxy/{session_id}/",
         }
+        if use_portless and portless_app_name:
+            result["portless_url"] = f"http://{portless_app_name}.localhost:1355/"
+            result["port"] = 1355
+        return result
 
     async def _monitor_output(self, session_id: str) -> None:
         """Background task: read dev server stdout and detect port."""
@@ -766,7 +871,7 @@ class DevServerManager:
         if not alive and info["status"] in ("running", "starting"):
             info["status"] = "error"
 
-        return {
+        result = {
             "running": alive and info["status"] == "running",
             "status": info["status"],
             "port": info.get("port"),
@@ -776,6 +881,12 @@ class DevServerManager:
             "framework": info.get("framework"),
             "output": info.get("output_lines", [])[-20:],
         }
+        if info.get("use_portless") and info.get("portless_app_name"):
+            app_name = info["portless_app_name"]
+            result["portless_url"] = f"http://{app_name}.localhost:1355/"
+            if alive:
+                result["port"] = 1355
+        return result
 
     async def stop_all(self) -> None:
         """Stop all dev servers (used on shutdown)."""
@@ -2308,6 +2419,14 @@ async def chat_session(session_id: str, req: ChatRequest) -> JSONResponse:
                         break
                     # Strip ANSI escape codes for clean display
                     clean = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', raw_line.rstrip("\n"))
+                    # Filter out noisy tool-use output lines from Claude
+                    stripped = clean.strip()
+                    if stripped in ("[Tool: Read]", "[Tool: Bash]", "[Tool: Write]",
+                                    "[Tool: Edit]", "[Tool: Grep]", "[Tool: Glob]",
+                                    "[Result]", "[Thinking]"):
+                        continue
+                    if not stripped:
+                        continue
                     task.output_lines.append(clean)
                 proc.stdout.close()
 
@@ -2630,7 +2749,7 @@ async def get_preview_info(session_id: str) -> JSONResponse:
         info["type"] = "web-app"
         info["entry_file"] = "index.html"
         info["preview_url"] = f"/api/sessions/{session_id}/preview/index.html"
-        info["dev_command"] = pkg_scripts.get("dev") or pkg_scripts.get("start")
+        info["dev_command"] = "npm run dev" if "dev" in pkg_scripts else "npm start" if "start" in pkg_scripts else None
         info["description"] = "Web application -- serves HTML/CSS/JS"
     elif is_express or (has_package_json and ("start" in pkg_scripts or "dev" in pkg_scripts) and not has_index_html):
         # API/server project
@@ -2642,7 +2761,7 @@ async def get_preview_info(session_id: str) -> JSONResponse:
             port = int(port_match.group(1))
         info["type"] = "api"
         info["port"] = port
-        info["dev_command"] = pkg_scripts.get("dev") or pkg_scripts.get("start")
+        info["dev_command"] = "npm run dev" if "dev" in pkg_scripts else "npm start" if "start" in pkg_scripts else None
         info["description"] = f"API server -- runs on port {port}"
         # Check for swagger/openapi
         for swagger_path in ["swagger.json", "openapi.json", "docs", "api-docs"]:
@@ -2661,7 +2780,7 @@ async def get_preview_info(session_id: str) -> JSONResponse:
         info["description"] = "Static site -- serves HTML directly"
     elif has_package_json and "test" in pkg_scripts:
         info["type"] = "library"
-        info["dev_command"] = pkg_scripts.get("test")
+        info["dev_command"] = "npm test"
         info["description"] = "Library/package -- run tests to verify"
     elif has_go_mod:
         info["type"] = "go-app"
@@ -2708,8 +2827,12 @@ async def start_devserver(session_id: str, req: DevServerStartRequest) -> JSONRe
     target = _find_session_dir(session_id)
     if target is None:
         return JSONResponse(status_code=404, content={"error": "Session not found"})
-    result = await dev_server_manager.start(session_id, str(target), req.command)
-    status_code = 200 if result.get("status") != "error" else 500
+    try:
+        result = await dev_server_manager.start(session_id, str(target), req.command)
+    except Exception as e:
+        logger.error("Dev server start failed: %s", e)
+        result = {"status": "error", "message": str(e)}
+    status_code = 200 if result.get("status") != "error" else 400
     return JSONResponse(content=result, status_code=status_code)
 
 
@@ -2753,8 +2876,17 @@ async def proxy_to_devserver(session_id: str, path: str, request: Request):
             status_code=503,
         )
 
-    target_port = server["port"]
-    target_url = f"http://127.0.0.1:{target_port}/{path}"
+    # Determine target: portless URL or direct port
+    if server.get("use_portless") and server.get("portless_app_name"):
+        app_name = server["portless_app_name"]
+        target_host = f"{app_name}.localhost"
+        target_port = 1355
+        target_url = f"http://{target_host}:{target_port}/{path}"
+    else:
+        target_port = server["port"]
+        target_host = f"127.0.0.1:{target_port}"
+        target_url = f"http://127.0.0.1:{target_port}/{path}"
+
     if request.url.query:
         target_url += f"?{request.url.query}"
 
@@ -2765,7 +2897,7 @@ async def proxy_to_devserver(session_id: str, path: str, request: Request):
         k: v for k, v in request.headers.items()
         if k.lower() not in skip_headers
     }
-    fwd_headers["host"] = f"127.0.0.1:{target_port}"
+    fwd_headers["host"] = target_host
 
     body = await request.body()
 
@@ -2837,9 +2969,13 @@ async def proxy_websocket(websocket: WebSocket, session_id: str, path: str):
         await websocket.close(code=1008, reason="Dev server not running")
         return
 
-    target_port = server["port"]
-    # Forward the exact sub-path to the upstream dev server
-    ws_url = f"ws://127.0.0.1:{target_port}/{path}"
+    # Determine WebSocket target: portless or direct
+    if server.get("use_portless") and server.get("portless_app_name"):
+        app_name = server["portless_app_name"]
+        ws_url = f"ws://{app_name}.localhost:1355/{path}"
+    else:
+        target_port = server["port"]
+        ws_url = f"ws://127.0.0.1:{target_port}/{path}"
 
     await websocket.accept()