loki-mode 6.52.0 → 6.54.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

@@ -2308,6 +2308,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()
 
@@ -2583,13 +2591,22 @@ async def get_preview_info(session_id: str) -> JSONResponse:
         "description": "No preview available",
     }
 
-    # Detect project type from files
+    # Detect project type from files (check root and first-level subdirectories)
     files = {f.name for f in target.iterdir() if f.is_file()} if target.is_dir() else set()
     has_package_json = "package.json" in files
+    # If package.json not at root, check immediate subdirectories (e.g. project inside a folder)
+    project_root = target
+    if not has_package_json and target.is_dir():
+        for subdir in target.iterdir():
+            if subdir.is_dir() and (subdir / "package.json").exists():
+                project_root = subdir
+                files = {f.name for f in subdir.iterdir() if f.is_file()}
+                has_package_json = True
+                break
     has_index_html = (
         "index.html" in files
-        or (target / "public" / "index.html").exists()
-        or (target / "src" / "index.html").exists()
+        or (project_root / "public" / "index.html").exists()
+        or (project_root / "src" / "index.html").exists()
     )
     has_pyproject = "pyproject.toml" in files or "setup.py" in files or "requirements.txt" in files
     has_go_mod = "go.mod" in files
@@ -2601,7 +2618,7 @@ async def get_preview_info(session_id: str) -> JSONResponse:
     pkg_deps: dict = {}
     if has_package_json:
         try:
-            pkg = json.loads((target / "package.json").read_text())
+            pkg = json.loads((project_root / "package.json").read_text())
             pkg_scripts = pkg.get("scripts", {})
             pkg_deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
         except (json.JSONDecodeError, OSError):
@@ -2610,11 +2627,11 @@ async def get_preview_info(session_id: str) -> JSONResponse:
     # Determine project type and preview strategy
     is_react = "react" in pkg_deps or "next" in pkg_deps or "vite" in pkg_deps
     is_express = "express" in pkg_deps or "fastify" in pkg_deps or "koa" in pkg_deps or "hono" in pkg_deps
-    is_flask = has_pyproject and any((target / f).exists() for f in ["app.py", "main.py", "server.py"])
+    is_flask = has_pyproject and any((project_root / f).exists() for f in ["app.py", "main.py", "server.py"])
     is_fastapi = has_pyproject and any(
-        "fastapi" in (target / f).read_text(errors="replace")
+        "fastapi" in (project_root / f).read_text(errors="replace")
         for f in ["app.py", "main.py", "server.py"]
-        if (target / f).exists()
+        if (project_root / f).exists()
     )
 
     if is_react or (has_package_json and has_index_html):
@@ -3282,13 +3299,24 @@ async def terminal_websocket(ws: WebSocket, session_id: str) -> None:
     await ws.accept()
 
     if not HAS_PEXPECT:
-        await ws.send_text(json.dumps({
-            "type": "output",
-            "data": "\r\n[Error] pexpect is not installed. "
-                    "Run: pip install pexpect\r\n",
-        }))
-        await ws.close()
-        return
+        # Try to install pexpect automatically
+        import subprocess as _sp
+        try:
+            _sp.run(
+                [sys.executable, "-m", "pip", "install", "--break-system-packages", "pexpect"],
+                capture_output=True, timeout=30,
+            )
+            import pexpect as _pex  # noqa: F811
+            globals()["HAS_PEXPECT"] = True
+        except Exception:
+            await ws.send_text(json.dumps({
+                "type": "output",
+                "data": "\r\n[Error] pexpect is not installed and auto-install failed.\r\n"
+                        "Run: pip install pexpect\r\n",
+            }))
+            # Close with 4000 = "do not retry" custom code
+            await ws.close(code=4000, reason="pexpect not installed")
+            return
 
     # ---- Reuse or spawn PTY ------------------------------------------------
     pty = _terminal_ptys.get(session_id)