footprinter-cli 1.0.0__py3-none-any.whl

footprinter/db/messages.py

@@ -0,0 +1,192 @@
+"""Cross-chat message queries.
+
+Provides list, get, and search functions for messages across all chats.
+All functions take sqlite3.Connection and return plain dicts.
+"""
+
+import sqlite3
+from typing import Optional
+
+from footprinter.db.sql_utils import paginate, paginated_response
+
+
+def list_messages(
+    conn: sqlite3.Connection,
+    *,
+    role: Optional[str] = None,
+    account: Optional[str] = None,
+    chat_id: Optional[int] = None,
+    limit: int = 50,
+    page: int = 1,
+) -> dict:
+    """List messages across chats with optional filters and pagination.
+
+    Parameters
+    ----------
+    conn : sqlite3.Connection
+    role : optional role filter (e.g. 'user', 'assistant')
+    account : optional account filter (e.g. 'claude', 'chatgpt')
+    chat_id : optional chat ID to filter to a single chat
+    limit : max rows per page
+    page : 1-based page number
+
+    Returns
+    -------
+    dict with keys: messages, pagination
+    """
+    conditions: list[str] = []
+    params: list = []
+
+    if role:
+        conditions.append("message.role = ?")
+        params.append(role)
+
+    if account:
+        conditions.append("chat.account = ?")
+        params.append(account)
+
+    if chat_id is not None:
+        conditions.append("message.chat_id = ?")
+        params.append(chat_id)
+
+    where = "WHERE " + " AND ".join(conditions) if conditions else ""
+
+    count_sql = f"""
+        SELECT COUNT(*)
+        FROM messages message
+        JOIN chats chat ON message.chat_id = chat.id
+        {where}
+    """
+    fetch_sql = f"""
+        SELECT message.id, message.chat_id, message.message_id, message.role, message.content, message.created_at,
+               chat.title AS chat_title, chat.account AS chat_account,
+               message.mcp_view, message.mcp_read
+        FROM messages message
+        JOIN chats chat ON message.chat_id = chat.id
+        {where}
+        ORDER BY message.id DESC
+        LIMIT ? OFFSET ?
+    """
+
+    rows, pagination = paginate(conn, count_sql, fetch_sql, params, page=page, limit=limit)
+
+    messages = [
+        {
+            "id": r["id"],
+            "chat_id": r["chat_id"],
+            "message_id": r["message_id"],
+            "role": r["role"],
+            "content": r["content"],
+            "created_at": r["created_at"],
+            "chat_title": r["chat_title"],
+            "chat_account": r["chat_account"],
+            "mcp_view": r["mcp_view"],
+            "mcp_read": r["mcp_read"],
+        }
+        for r in rows
+    ]
+
+    return paginated_response("messages", messages, pagination)
+
+
+def get_message(conn: sqlite3.Connection, message_id: int) -> Optional[dict]:
+    """Get a single message with chat context.
+
+    Parameters
+    ----------
+    conn : sqlite3.Connection
+    message_id : internal integer ID
+
+    Returns
+    -------
+    dict with message fields and chat context, or None if not found
+    """
+    cursor = conn.execute(
+        """
+        SELECT message.id, message.chat_id, message.message_id, message.role, message.content, message.created_at,
+               chat.title AS chat_title, chat.account AS chat_account,
+               message.mcp_view, message.mcp_read
+        FROM messages message
+        JOIN chats chat ON message.chat_id = chat.id
+        WHERE message.id = ?
+        """,
+        (message_id,),
+    )
+    row = cursor.fetchone()
+    if not row:
+        return None
+
+    return {
+        "id": row["id"],
+        "chat_id": row["chat_id"],
+        "message_id": row["message_id"],
+        "role": row["role"],
+        "content": row["content"],
+        "created_at": row["created_at"],
+        "chat_title": row["chat_title"],
+        "chat_account": row["chat_account"],
+        "mcp_view": row["mcp_view"],
+        "mcp_read": row["mcp_read"],
+    }
+
+
+def search_messages(
+    conn: sqlite3.Connection,
+    query: str,
+    *,
+    limit: int = 50,
+    page: int = 1,
+) -> dict:
+    """Search message content across all chats.
+
+    Parameters
+    ----------
+    conn : sqlite3.Connection
+    query : search term
+    limit : max results per page
+    page : 1-based page number
+
+    Returns
+    -------
+    dict with keys: results, pagination
+    """
+    if len(query) < 2:
+        return paginated_response("results", [], {"page": page, "limit": limit, "total": 0, "total_pages": 1})
+
+    query_param = f"%{query}%"
+    count_sql = """
+        SELECT COUNT(*)
+        FROM messages message
+        JOIN chats chat ON message.chat_id = chat.id
+        WHERE message.content LIKE ?
+    """
+    fetch_sql = """
+        SELECT message.id, message.chat_id, message.message_id, message.role, message.content, message.created_at,
+               chat.title AS chat_title, chat.account AS chat_account,
+               message.mcp_view, message.mcp_read
+        FROM messages message
+        JOIN chats chat ON message.chat_id = chat.id
+        WHERE message.content LIKE ?
+        ORDER BY message.id DESC
+        LIMIT ? OFFSET ?
+    """
+
+    rows, pagination = paginate(conn, count_sql, fetch_sql, [query_param], page=page, limit=limit)
+
+    results = [
+        {
+            "id": r["id"],
+            "chat_id": r["chat_id"],
+            "message_id": r["message_id"],
+            "role": r["role"],
+            "content": r["content"],
+            "created_at": r["created_at"],
+            "chat_title": r["chat_title"],
+            "chat_account": r["chat_account"],
+            "mcp_view": r["mcp_view"],
+            "mcp_read": r["mcp_read"],
+        }
+        for r in rows
+    ]
+
+    return paginated_response("results", results, pagination)

footprinter/db/policies.py

@@ -0,0 +1,151 @@
+"""Access control policy CRUD — visibility and permission layers."""
+
+import sqlite3
+
+PERMISSION_SETTINGS = frozenset({"allow", "deny"})
+VISIBILITY_SETTINGS = frozenset({"visible", "opaque", "hidden"})
+
+SCOPE_PREFIXES = frozenset({"source", "account", "folder", "project", "client", "file", "email", "chat"})
+VALID_SOURCE_TYPES = frozenset({"files", "emails", "chats", "folders", "browser", "projects", "clients"})
+_ID_PREFIXES = frozenset({"project", "client", "file", "email", "chat"})
+
+
+def is_folder_path_scope(scope: str) -> bool:
+    """True if scope is a folder path prefix (not a numeric folder ID)."""
+    suffix = scope[len("folder:") :]
+    return not suffix.isdigit()
+
+
+def validate_scope(scope: str) -> None:
+    """Raise ValueError if *scope* is not a recognised scope pattern."""
+    if scope == "global":
+        return
+    if ":" in scope:
+        prefix, value = scope.split(":", 1)
+        if prefix not in SCOPE_PREFIXES:
+            raise ValueError(f"Invalid scope: {scope!r}. Unknown prefix {prefix!r}.")
+        if not value or value.isspace():
+            raise ValueError(f"Invalid scope: {scope!r}. Value after '{prefix}:' must not be empty.")
+        if prefix == "source" and value not in VALID_SOURCE_TYPES:
+            raise ValueError(f"Invalid scope: {scope!r}. Valid source types: {', '.join(sorted(VALID_SOURCE_TYPES))}")
+        if prefix in _ID_PREFIXES:
+            try:
+                int(value)
+            except ValueError:
+                raise ValueError(f"Invalid scope: {scope!r}. '{prefix}:' requires a numeric ID.") from None
+        return
+    raise ValueError(f"Invalid scope: {scope!r}. Expected 'global' or 'prefix:value'.")
+
+
+# ---------------------------------------------------------------------------
+# Visibility policies
+# ---------------------------------------------------------------------------
+
+
+def list_visibility_policies(conn: sqlite3.Connection) -> list[dict]:
+    """Return all visibility policies as plain dicts."""
+    rows = conn.execute("SELECT scope, setting, updated_at FROM visibility_policies ORDER BY scope").fetchall()
+    return [{"scope": r["scope"], "setting": r["setting"], "updated_at": r["updated_at"]} for r in rows]
+
+
+def set_visibility_policy(conn: sqlite3.Connection, scope: str, setting: str) -> bool:
+    """Insert or update a visibility policy. Returns True."""
+    validate_scope(scope)
+    if setting not in VISIBILITY_SETTINGS:
+        raise ValueError(f"Invalid visibility setting: {setting}. Valid: {', '.join(sorted(VISIBILITY_SETTINGS))}")
+    conn.execute(
+        "INSERT OR REPLACE INTO visibility_policies (scope, setting, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+        (scope, setting),
+    )
+    conn.commit()
+    return True
+
+
+def delete_visibility_policy(conn: sqlite3.Connection, scope: str) -> bool:
+    """Delete a visibility policy. Returns True if a row was removed."""
+    cur = conn.cursor()
+    cur.execute("DELETE FROM visibility_policies WHERE scope = ?", (scope,))
+    deleted = cur.rowcount > 0
+    conn.commit()
+    return deleted
+
+
+def clear_visibility_policies(conn: sqlite3.Connection) -> int:
+    """Delete all visibility policies. Returns count of rows removed."""
+    cur = conn.cursor()
+    cur.execute("DELETE FROM visibility_policies")
+    count = cur.rowcount
+    conn.commit()
+    return count
+
+
+def seed_visibility_defaults(conn: sqlite3.Connection) -> bool:
+    """Seed ``global=visible`` into visibility_policies. Idempotent."""
+    cur = conn.cursor()
+    cur.execute("INSERT OR IGNORE INTO visibility_policies (scope, setting) VALUES ('global', 'visible')")
+    seeded = cur.rowcount > 0
+    conn.commit()
+    return seeded
+
+
+# ---------------------------------------------------------------------------
+# Permission policies
+# ---------------------------------------------------------------------------
+
+
+def list_permission_policies(conn: sqlite3.Connection) -> list[dict]:
+    """Return all permission policies as plain dicts."""
+    rows = conn.execute("SELECT scope, setting, updated_at FROM permission_policies ORDER BY scope").fetchall()
+    return [{"scope": r["scope"], "setting": r["setting"], "updated_at": r["updated_at"]} for r in rows]
+
+
+def set_permission_policy(conn: sqlite3.Connection, scope: str, setting: str) -> bool:
+    """Insert or update a permission policy. Returns True."""
+    validate_scope(scope)
+    if setting not in PERMISSION_SETTINGS:
+        raise ValueError(f"Invalid permission setting: {setting}. Valid: {', '.join(sorted(PERMISSION_SETTINGS))}")
+    conn.execute(
+        "INSERT OR REPLACE INTO permission_policies (scope, setting, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)",
+        (scope, setting),
+    )
+    conn.commit()
+    return True
+
+
+def delete_permission_policy(conn: sqlite3.Connection, scope: str) -> bool:
+    """Delete a permission policy. Returns True if a row was removed."""
+    cur = conn.cursor()
+    cur.execute("DELETE FROM permission_policies WHERE scope = ?", (scope,))
+    deleted = cur.rowcount > 0
+    conn.commit()
+    return deleted
+
+
+def clear_permission_policies(conn: sqlite3.Connection) -> int:
+    """Delete all permission policies. Returns count of rows removed."""
+    cur = conn.cursor()
+    cur.execute("DELETE FROM permission_policies")
+    count = cur.rowcount
+    conn.commit()
+    return count
+
+
+def seed_permission_defaults(conn: sqlite3.Connection) -> bool:
+    """Seed ``global=allow`` into permission_policies. Idempotent."""
+    cur = conn.cursor()
+    cur.execute("INSERT OR IGNORE INTO permission_policies (scope, setting) VALUES ('global', 'allow')")
+    seeded = cur.rowcount > 0
+    conn.commit()
+    return seeded
+
+
+# ---------------------------------------------------------------------------
+# Combined seed
+# ---------------------------------------------------------------------------
+
+
+def seed_access_policies(conn: sqlite3.Connection) -> dict:
+    """Seed both visibility and permission defaults. Returns status dict."""
+    vis = seed_visibility_defaults(conn)
+    perm = seed_permission_defaults(conn)
+    return {"visibility_seeded": vis, "permission_seeded": perm}