utim-cli 1.46.5__tar.gz → 1.46.7__tar.gz

{utim_cli-1.46.5/utim_cli.egg-info → utim_cli-1.46.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: utim-cli
-Version: 1.46.5
+Version: 1.46.7
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: MIT
 Project-URL: Homepage, https://utim.dev

{utim_cli-1.46.5 → utim_cli-1.46.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "1.46.5"
+version = "1.46.7"
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"
 requires-python = ">=3.9"

{utim_cli-1.46.5 → utim_cli-1.46.7}/utim_cli/auth.py

@@ -90,73 +90,135 @@ class _AuthCallbackHandler(http.server.BaseHTTPRequestHandler):
 
 def login() -> None:
     """
-    Sign in by prompting the user to copy their UTIM API key from the web dashboard.
+    Sign in via the Device Authorization Flow.
+    
+    1. CLI requests a one-time code from the server.
+    2. CLI displays a short URL + code and starts background polling.
+    3. User visits the URL, signs in via Firebase, clicks Authorize.
+    4. Server marks the code authorized — CLI poll receives the API key.
+    5. Code is immediately burned server-side (single use, never reusable).
     """
-    # Sleep briefly to ensure prompt_toolkit's terminal-suspension/clearing sequences
-    # are fully processed by the terminal emulator before we print.
+    import sys
     import time
+    import threading
+
+    # Sleep briefly to ensure prompt_toolkit's terminal-suspension sequences are flushed
     time.sleep(0.3)
 
-    # ANSI escape codes for formatting
+    # ANSI formatting
     PURPLE = "\033[1;35m"
-    BLUE = "\033[1;34m"
+    BLUE   = "\033[1;34m"
     YELLOW = "\033[1;33m"
-    WHITE = "\033[1;37m"
-    RESET = "\033[0m"
-    DIM = "\033[2m"
-
-    print(f"\n  {PURPLE}UTIM CLI Sign-In{RESET}")
-    print("  1. Visit the UTIM Profile page in your browser:")
-    print(f"     {BLUE}{WEB_URL}/profile{RESET}")
-    print(f"  2. Copy your {WHITE}UTIM API Key{RESET}.")
-    print("  3. Paste the key below to log in.\n")
+    GREEN  = "\033[1;32m"
+    DIM    = "\033[2m"
+    BOLD   = "\033[1m"
+    RESET  = "\033[0m"
 
-    import sys
+    print(f"\n  {PURPLE}UTIM CLI — Secure Device Sign-In{RESET}\n")
+    print(f"  {DIM}Requesting authorization code from UTIM server…{RESET}")
     sys.stdout.flush()
 
-    # Try to open the profile page in a background thread for convenience
-    threading.Thread(target=webbrowser.open, args=(f"{WEB_URL}/profile",), daemon=True).start()
+    # Step 1 — request a device code from the server
+    try:
+        resp = requests.post(
+            f"{SERVER_URL}/auth/device/request",
+            timeout=15,
+        )
+        if resp.status_code != 200:
+            print(f"\n  \033[1;31m✗ Server error (HTTP {resp.status_code}). Please try again.\033[0m\n")
+            sys.stdout.flush()
+            return
+        data = resp.json()
+    except Exception as exc:
+        print(f"\n  \033[1;31m✗ Could not reach UTIM server: {exc}\033[0m\n")
+        sys.stdout.flush()
+        return
+
+    device_code  = data["device_code"]
+    user_code    = data["user_code"]
+    verify_url   = data["verify_url"]
+    expires_in   = data.get("expires_in", 600)
+    poll_interval = data.get("poll_interval", 3)
+
+    # Step 2 — show the user what to do
+    print(f"\n  {BOLD}To sign in, visit:{RESET}")
+    print(f"\n    {BLUE}{verify_url}{RESET}\n")
+    print(f"  Or visit {BLUE}{WEB_URL}/activate{RESET} and enter code:")
+    print(f"\n    {YELLOW}{BOLD}{user_code}{RESET}\n")
+    print(f"  {DIM}Waiting for you to authorize in the browser… (expires in {expires_in // 60} minutes){RESET}\n")
+    sys.stdout.flush()
 
+    # Try to open the browser in background (convenience — not required)
+    threading.Thread(target=webbrowser.open, args=(verify_url,), daemon=True).start()
+
+    # Step 3 — poll in background thread, signal main thread via Event
+    result: dict = {}
+    done_event = threading.Event()
+
+    def _poll():
+        deadline = time.time() + expires_in
+        while time.time() < deadline:
+            time.sleep(poll_interval)
+            try:
+                pr = requests.get(
+                    f"{SERVER_URL}/auth/device/poll",
+                    params={"device_code": device_code},
+                    timeout=10,
+                )
+                if pr.status_code != 200:
+                    continue
+                body = pr.json()
+                status = body.get("status")
+                if status == "authorized":
+                    result.update(body)
+                    done_event.set()
+                    return
+                elif status == "expired":
+                    result["status"] = "expired"
+                    done_event.set()
+                    return
+                # status == "pending" → keep polling
+            except Exception:
+                pass  # network hiccup — keep polling
+        result["status"] = "expired"
+        done_event.set()
+
+    poll_thread = threading.Thread(target=_poll, daemon=True)
+    poll_thread.start()
+
+    # Step 4 — block the main thread until authorized or expired
+    # NOTE: We do NOT call input() here — that would hold an OS-level lock on stdin,
+    # causing prompt_toolkit to deadlock after login() returns.
+    # Instead we use done_event.wait() which is pure threading with no stdin involvement.
+    # Ctrl+C still works to abort (KeyboardInterrupt propagates normally).
     try:
-        api_key = input("  Enter UTIM API Key (or press Enter to cancel): ").strip()
-    except (EOFError, KeyboardInterrupt):
-        print("\n  \033[1;33mCancelled.\033[0m\n")
+        done_event.wait(timeout=expires_in + 5)
+    except KeyboardInterrupt:
+        print(f"\n  {YELLOW}Cancelled.{RESET}\n")
         sys.stdout.flush()
         return
 
-    if not api_key:
-        print("\n  \033[1;33mCancelled.\033[0m\n")
+    # Step 5 — process result
+    if result.get("status") == "expired":
+        print(f"\n  \033[1;31m✗ Authorization code expired. Please run /login again.\033[0m\n")
         sys.stdout.flush()
         return
 
-    print(f"  {DIM}Verifying with UTIM server…{RESET}")
-    sys.stdout.flush()
-    try:
-        resp = requests.get(
-            f"{SERVER_URL}/auth/me",
-            headers={"X-API-Key": api_key},
-            timeout=15,
-        )
-        if resp.status_code != 200:
-            print(f"  \033[1;31m✗ Invalid API Key or server error (HTTP {resp.status_code}).\033[0m\n")
-            sys.stdout.flush()
-            return
-        payload = resp.json()
-    except Exception as exc:
-        print(f"  \033[1;31m✗ Verification failed: {exc}\033[0m\n")
+    if result.get("status") != "authorized":
+        print(f"\n  \033[1;31m✗ Authorization failed. Please try again.\033[0m\n")
         sys.stdout.flush()
         return
 
     # Persist credentials
-    config.set("token",    "direct_key")  # sentinel
-    config.set("email",    payload["email"])
-    config.set("uid",      payload["user_id"])
-    config.set("name",     payload.get("display_name") or payload["email"].split("@")[0])
-    config.set("api_key",  api_key)
-
-    print(f"  {YELLOW}✓ Welcome back!{RESET}\n")
-    print(f"  Signed in as {BLUE}{payload['email']}{RESET}\n")
-    print(f"  Credits: {payload['credits']:,.0f} UTIM\n")
+    config.set("token",   "device_flow")  # sentinel
+    config.set("email",   result.get("email", ""))
+    config.set("uid",     result.get("user_id", ""))
+    config.set("name",    result.get("display_name") or result.get("email", "").split("@")[0])
+    config.set("api_key", result["api_key"])
+
+    print(f"\n  {GREEN}✓ Authorized! Welcome back.{RESET}")
+    print(f"  Signed in as {BLUE}{result.get('email', '')}{RESET}")
+    print(f"  Credits: {result.get('credits', 0):,.0f} UTIM\n")
     sys.stdout.flush()
 
 

{utim_cli-1.46.5 → utim_cli-1.46.7}/utim_cli/bootstrap.py

@@ -126,8 +126,8 @@ def initialize_utim() -> str:
     
     # 1. Initialize local_utim database using SQLAlchemy init_db
     try:
-        from utim_cli.server.db import init_db
-        init_db(silent=True)
+        from utim_cli.local_db import init_local_db
+        init_local_db(silent=True)
     except Exception as e:
         from utim_cli.logger import log_error
         log_error("bootstrap", "Failed to initialize SQLite local database", e)

utim_cli-1.46.7/utim_cli/local_db.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+import os
+import uuid
+import json
+import datetime
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+from sqlalchemy import (
+    Column, String, Text, Integer, Float, BigInteger, DateTime,
+    create_engine, event, Index, ForeignKey
+)
+from sqlalchemy.orm import DeclarativeBase, sessionmaker, relationship
+
+# ─── Database Base & Models ───────────────────────────────────────────────────
+
+class Base(DeclarativeBase):
+    pass
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    email = Column(String(255), unique=True, nullable=False, index=True)
+    conversations = relationship("Conversation", back_populates="user", cascade="all, delete-orphan")
+
+class Conversation(Base):
+    __tablename__ = "conversations"
+    id = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+    model_id = Column(String(128), nullable=True)
+    title = Column(String(255), nullable=True)
+    messages = Column(Text, nullable=False, default="[]")
+    turn_history = Column(Text, nullable=True, default="[]")
+    redo_history = Column(Text, nullable=True, default="[]")
+    token_usage_input = Column(BigInteger, default=0)
+    token_usage_output = Column(BigInteger, default=0)
+    created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
+
+    user = relationship("User", back_populates="conversations")
+
+# ─── Connection Wiring ───────────────────────────────────────────────────────
+
+def _get_local_engine():
+    """Return a SQLAlchemy engine connected to .utim/utim_local.db (cwd)."""
+    utim_dir = Path(os.getcwd()) / ".utim"
+    utim_dir.mkdir(parents=True, exist_ok=True)
+    db_path = utim_dir / "utim_local.db"
+    url = f"sqlite:///{db_path}"
+    engine = create_engine(url, connect_args={"check_same_thread": False})
+    
+    # Ensure WAL mode for safe concurrent access from background threads
+    @event.listens_for(engine, "connect")
+    def _set_wal(conn, _):
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA synchronous=NORMAL")
+        
+    Base.metadata.create_all(bind=engine)
+    return engine
+
+def _make_session():
+    engine = _get_local_engine()
+    return sessionmaker(autocommit=False, autoflush=False, bind=engine)()
+
+def init_local_db(silent: bool = True):
+    """Idempotently initialize local SQLite tables."""
+    try:
+        _get_local_engine()
+    except Exception as e:
+        if not silent:
+            print(f"Error initializing local DB: {e}")
+
+# Default local user for fully local / unauthenticated operation
+LOCAL_EMAIL = os.getenv("UTIM_EMAIL", "local@utim.dev")
+
+# ─── JSON Serialization Helpers ─────────────────────────────────────────────
+
+def _parse_json_field(value, default=None):
+    if default is None:
+        default = []
+    if value is None:
+        return default
+    if isinstance(value, (list, dict)):
+        return value
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (json.JSONDecodeError, ValueError):
+            return default
+    return default
+
+def _to_json(value):
+    if value is None:
+        return "[]"
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False)
+
+# ─── User Helper ────────────────────────────────────────────────────────────
+
+def get_or_create_user(db, email: str) -> User:
+    user = db.query(User).filter(User.email == email).first()
+    if not user:
+        user = User(email=email)
+        db.add(user)
+        db.commit()
+        db.refresh(user)
+    return user
+
+# ─── History Manager ────────────────────────────────────────────────────────
+
+class HistoryManager:
+    def __init__(self):
+        pass
+
+    def get_session(self, session_id: str, email: str = None) -> Dict[str, Any] | None:
+        db = _make_session()
+        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
+        if not conv:
+            db.close()
+            return None
+        res = {
+            "session_id": conv.id,
+            "model_id": conv.model_id,
+            "messages": _parse_json_field(conv.messages),
+            "turn_history": _parse_json_field(conv.turn_history),
+            "redo_history": _parse_json_field(conv.redo_history),
+            "usage": {
+                "input_tokens": conv.token_usage_input,
+                "output_tokens": conv.token_usage_output
+            }
+        }
+        db.close()
+        return res
+
+    def create_session(self, model_id: str, email: str = None) -> str:
+        email = email or LOCAL_EMAIL
+        db = _make_session()
+        user = get_or_create_user(db, email)
+        session_id = str(uuid.uuid4())
+        new_conv = Conversation(
+            id=session_id,
+            user_id=user.id,
+            model_id=model_id,
+            messages=_to_json([]),
+            turn_history=_to_json([]),
+            redo_history=_to_json([])
+        )
+        db.add(new_conv)
+        db.commit()
+        db.close()
+        return session_id
+
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, first_user_msg: str = "", turn_history: List[Dict[str, Any]] = None, redo_history: List[Dict[str, Any]] = None):
+        email = email or LOCAL_EMAIL
+        db = _make_session()
+        user = get_or_create_user(db, email)
+
+        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
+        if conv:
+            conv.user_id = user.id
+            conv.messages = _to_json(messages)
+            if turn_history is not None:
+                conv.turn_history = _to_json(turn_history)
+            if redo_history is not None:
+                conv.redo_history = _to_json(redo_history)
+                
+            if first_user_msg and not conv.title:
+                conv.title = (first_user_msg[:80] + "\u2026" if len(first_user_msg) > 80 else first_user_msg)
+            
+            db.commit()
+        db.close()
+
+    def checkpoint(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, description: str = "auto"):
+        pass
+
+    def list_sessions(self, email: str = None):
+        db = _make_session()
+        conversations = db.query(Conversation).all()
+        sessions = []
+        for c in conversations:
+            msgs = _parse_json_field(c.messages)
+            has_user_msg = any(isinstance(m, dict) and m.get("role") == "user" for m in msgs)
+            if not has_user_msg:
+                continue
+            first_user = next(
+                (m.get("content", "") for m in msgs if isinstance(m, dict) and m.get("role") == "user"),
+                ""
+            )
+            if isinstance(first_user, list):
+                first_user = " ".join(p.get("text", "") for p in first_user if isinstance(p, dict))
+            title = c.title or (first_user[:70] + "\u2026" if len(first_user) > 70 else first_user) or c.id[:12]
+            sessions.append({
+                "session_id": c.id,
+                "model_id": c.model_id,
+                "message_count": len(msgs),
+                "title": title,
+                "created_at": c.created_at.isoformat() if hasattr(c, "created_at") and c.created_at else "",
+                "updated_at": c.updated_at.isoformat() if c.updated_at else "",
+            })
+        db.close()
+        sessions.sort(key=lambda s: s["updated_at"], reverse=True)
+        return sessions

{utim_cli-1.46.5 → utim_cli-1.46.7}/utim_cli/orchestrator.py

@@ -376,7 +376,7 @@ class Orchestrator:
         if not self.session_id:
             # Create a local session if we don't have one
             try:
-                from utim_cli.server.history import HistoryManager
+                from utim_cli.local_db import HistoryManager
                 hm = HistoryManager()
                 # Use the orchestrator's email (which defaults to local@utim.dev)
                 user_email = self.email or os.getenv("UTIM_EMAIL", "local@utim.dev")
@@ -430,10 +430,10 @@ class Orchestrator:
                     ]
                 clean_redo_history.append(clean_turn)
 
-        # Save to local database
+        # Save to local database and session_state.json
         def _save_local():
             try:
-                from utim_cli.server.history import HistoryManager
+                from utim_cli.local_db import HistoryManager
                 hm = HistoryManager()
                 hm.add_messages(
                     self.session_id,
@@ -443,6 +443,19 @@ class Orchestrator:
                     turn_history=clean_turn_history,
                     redo_history=clean_redo_history
                 )
+                
+                # Write current active session state to session_state.json
+                state_data = {
+                    "session_id": self.session_id,
+                    "messages": clean_messages,
+                    "turn_history": clean_turn_history,
+                    "redo_history": clean_redo_history,
+                    "model_id": self.model_id
+                }
+                os.makedirs(".utim", exist_ok=True)
+                with open(".utim/session_state.json", "w", encoding="utf-8") as f:
+                    json.dump(state_data, f, ensure_ascii=False, indent=4)
+
                 from utim_cli.backup import backup_state
                 backup_state()
             except Exception:

{utim_cli-1.46.5 → utim_cli-1.46.7}/utim_cli/server/db.py

@@ -204,6 +204,29 @@ class PaymentOrder(Base):
     user = relationship("User", back_populates="payment_orders")
 
 
+class DeviceAuthCode(Base):
+    """Single-use login token for the Device Authorization Flow (RFC 8628 inspired).
+    
+    Flow:
+      1. CLI POSTs /auth/device/request → gets device_code + user_code + verify_url
+      2. CLI polls /auth/device/poll?device_code=... every 3 seconds
+      3. User visits verify_url, signs in via Firebase, clicks Authorize
+      4. Server stores api_key in this row, sets status='authorized'
+      5. CLI poll response returns api_key, row is immediately invalidated
+    """
+    __tablename__ = "device_auth_codes"
+
+    id          = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    device_code = Column(String(64), unique=True, nullable=False, index=True,
+                         default=lambda: uuid.uuid4().hex)          # secret, only CLI sees this
+    user_code   = Column(String(9),  unique=True, nullable=False, index=True)  # e.g. "DFRG-TYHJ"
+    status      = Column(String(16), default="pending", nullable=False)        # pending|authorized|expired
+    api_key     = Column(String(64), nullable=True)                            # populated on authorization
+    user_id     = Column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=True)
+    expires_at  = Column(DateTime,   nullable=False)
+    created_at  = Column(DateTime,   default=datetime.datetime.utcnow, nullable=False)
+
+
 class EmotionVector(Base):
     __tablename__ = "emotion_vectors"
 

utim_cli-1.46.7/utim_cli/server/history.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+import json
+import os
+import uuid
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import sessionmaker
+
+from .db import Base, Conversation, User
+
+# ── Local DB wiring ───────────────────────────────────────────────────────────
+# Always use .utim/utim_local.db in the CURRENT WORKING DIRECTORY.
+# This is the file bootstrap.py creates and backup.py backs up.
+# We do NOT use the DATABASE_URL from server/db.py — that points at the
+# production PostgreSQL server, which is unreachable from the local CLI.
+
+def _get_local_engine():
+    """Return a SQLAlchemy engine connected to .utim/utim_local.db (cwd)."""
+    utim_dir = Path(os.getcwd()) / ".utim"
+    utim_dir.mkdir(parents=True, exist_ok=True)
+    db_path = utim_dir / "utim_local.db"
+    url = f"sqlite:///{db_path}"
+    engine = create_engine(url, connect_args={"check_same_thread": False})
+    # Ensure WAL mode for safe concurrent access from background threads
+    @event.listens_for(engine, "connect")
+    def _set_wal(conn, _):
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA synchronous=NORMAL")
+    # Create all tables if they don't exist yet (idempotent)
+    Base.metadata.create_all(bind=engine)
+    return engine
+
+def _make_session():
+    engine = _get_local_engine()
+    return sessionmaker(autocommit=False, autoflush=False, bind=engine)()
+
+# Default local user for fully local / unauthenticated operation
+LOCAL_EMAIL = os.getenv("UTIM_EMAIL", "local@utim.dev")
+
+
+def _parse_json_field(value, default=None):
+    """Safely parse a DB field that may be a JSON string (SQLite Text) or already
+    a Python object (PostgreSQL JSONB). Returns `default` on any failure."""
+    if default is None:
+        default = []
+    if value is None:
+        return default
+    if isinstance(value, (list, dict)):
+        return value          # PostgreSQL JSONB already parsed
+    if isinstance(value, str):
+        try:
+            return json.loads(value)
+        except (json.JSONDecodeError, ValueError):
+            return default
+    return default
+
+
+def _to_json(value):
+    """Serialize a Python list/dict to a JSON string for SQLite Text storage.
+    If the value is already a string, return it as-is."""
+    if value is None:
+        return "[]"
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False)
+
+
+def get_or_create_user(db, email: str) -> User:
+    user = db.query(User).filter(User.email == email).first()
+    if not user:
+        user = User(email=email)
+        db.add(user)
+        db.commit()
+        db.refresh(user)
+    return user
+
+
+class HistoryManager:
+    def __init__(self):
+        pass
+
+    def get_session(self, session_id: str, email: str = None) -> Dict[str, Any] | None:
+        db = _make_session()
+        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
+        if not conv:
+            db.close()
+            return None
+        res = {
+            "session_id": conv.id,
+            "model_id": conv.model_id,
+            "messages": _parse_json_field(conv.messages),
+            "turn_history": _parse_json_field(conv.turn_history),
+            "redo_history": _parse_json_field(conv.redo_history),
+            "usage": {
+                "input_tokens": conv.token_usage_input,
+                "output_tokens": conv.token_usage_output
+            }
+        }
+        db.close()
+        return res
+
+    def create_session(self, model_id: str, email: str = None) -> str:
+        email = email or LOCAL_EMAIL
+        db = _make_session()
+        user = get_or_create_user(db, email)
+        session_id = str(uuid.uuid4())
+        new_conv = Conversation(
+            id=session_id,
+            user_id=user.id,
+            model_id=model_id,
+            messages=_to_json([]),
+            turn_history=_to_json([]),
+            redo_history=_to_json([])
+        )
+        db.add(new_conv)
+        db.commit()
+        db.close()
+        return session_id
+
+    def add_messages(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, first_user_msg: str = "", turn_history: List[Dict[str, Any]] = None, redo_history: List[Dict[str, Any]] = None):
+        email = email or LOCAL_EMAIL
+        db = _make_session()
+        user = get_or_create_user(db, email)
+
+        conv = db.query(Conversation).filter(Conversation.id == session_id).first()
+        if conv:
+            # Dynamically update user association when credentials change
+            conv.user_id = user.id
+            conv.messages = _to_json(messages)
+            if turn_history is not None:
+                conv.turn_history = _to_json(turn_history)
+            if redo_history is not None:
+                conv.redo_history = _to_json(redo_history)
+                
+            # Update title from first user message if we have one
+            if first_user_msg and not conv.title:
+                conv.title = (first_user_msg[:80] + "\u2026" if len(first_user_msg) > 80 else first_user_msg)
+            
+            db.commit()
+        db.close()
+
+    def checkpoint(self, session_id: str, messages: List[Dict[str, Any]], email: str = None, description: str = "auto"):
+        pass
+
+    def list_sessions(self, email: str = None):
+        db = _make_session()
+        conversations = db.query(Conversation).all()
+        sessions = []
+        for c in conversations:
+            msgs = _parse_json_field(c.messages)
+            has_user_msg = any(isinstance(m, dict) and m.get("role") == "user" for m in msgs)
+            if not has_user_msg:
+                continue
+            first_user = next(
+                (m.get("content", "") for m in msgs if isinstance(m, dict) and m.get("role") == "user"),
+                ""
+            )
+            if isinstance(first_user, list):
+                first_user = " ".join(p.get("text", "") for p in first_user if isinstance(p, dict))
+            title = c.title or (first_user[:70] + "\u2026" if len(first_user) > 70 else first_user) or c.id[:12]
+            sessions.append({
+                "session_id": c.id,
+                "model_id": c.model_id,
+                "message_count": len(msgs),
+                "title": title,
+                "created_at": c.created_at.isoformat() if hasattr(c, "created_at") and c.created_at else "",
+                "updated_at": c.updated_at.isoformat() if c.updated_at else "",
+            })
+        db.close()
+        sessions.sort(key=lambda s: s["updated_at"], reverse=True)
+        return sessions