feat: Initial integration of ATProtoSocial (Bluesky) protocol

This commit introduces the initial implementation for supporting the ATProtoSocial (Bluesky) protocol within your application.

Key changes and features I implemented:

1.  **Core Protocol Structure:**
    *   I added new directories `src/sessions/atprotosocial` and `src/controller/atprotosocial`.
    *   I populated these with foundational files (`session.py`, `utils.py`, `handler.py`, `compose.py`, etc.), mirroring the Mastodon implementation structure but adapted for ATProtoSocial.

2.  **Authentication:**
    *   I implemented login and authorization using Bluesky SDK (handle and app password) in `sessions/atprotosocial/session.py`.
    *   I integrated this into your session management UI (`sessionManagerDialog.py`) to allow adding ATProtoSocial accounts.

3.  **Posting Capabilities:**
    *   I implemented sending text posts, posts with images, replies, and quoting posts in `sessions/atprotosocial/session.py` and `utils.py`.
    *   I updated `compose.py` to reflect ATProtoSocial's panel configuration (character limits, media support, quoting).

4.  **Notifications:**
    *   I implemented fetching and processing of notifications (likes, reposts, follows, mentions, replies, quotes) in `sessions/atprotosocial/session.py`.
    *   Notifications are formatted for display.

5.  **Timelines:**
    *   I implemented fetching and processing for home timeline and user-specific timelines in `sessions/atprotosocial/session.py`.
    *   This includes handling of posts, reposts, and replies within your application's buffer and message cache system.

6.  **User Actions:**
    *   I implemented core user actions: follow, unfollow, mute, unmute, block, unblock in `sessions/atprotosocial/utils.py`.
    *   I integrated these actions into the controller layer (`controller/atprotosocial/handler.py`) and exposed them via `session.get_user_actions()`.

7.  **User Management & Profile:**
    *   I implemented fetching user profiles, follower lists, following lists, and user search in `sessions/atprotosocial/utils.py` and `controller/atprotosocial/userList.py`.

8.  **UI Integration (Initial Pass):**
    *   I adapted your session management UI for ATProtoSocial account creation.
    *   I updated main controller logic to load the ATProtoSocial handler and create basic buffers (Home, Notifications).
    *   I modified menu item labels based on the active session type (e.g., "Post" vs "Toot", "Like" vs "Favorite").
    *   I integrated core actions like reposting and liking into existing UI flows.
    *   I added basic integration for timeline refresh and loading more items.
    *   I added placeholder integration for viewing user profiles and user-specific timelines.

**Current Status & Next Steps:**

This represents a significant portion of the ATProtoSocial integration. The backend logic for most core features is in place. The immediate next steps, which were part of the original plan but not yet completed, would be:

*   **Refining UI elements:** Fully implementing dedicated dialogs (compose, user profile), custom panels for new buffer types, and ensuring accurate rendering of ATProtoSocial posts and notifications.
*   **Completing Documentation:** Updating all relevant documentation files in `doc/` and `documentation/`.
*   **Updating Translations:** Adding new strings and updating translation files.
*   **Adding Tests:** Creating unit and integration tests for the new protocol.

I was not stuck on any particular point, but the UI integration is a large step that requires iterative refinement and testing for each component, which would naturally extend beyond a single development cycle for a feature of this scope.

src/controller/atprotosocial/userActions.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+fromapprove.translation import translate as _
+# fromapprove.controller.mastodon import userActions as mastodon_user_actions # If adapting
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession # Adjusted
+
+logger = logging.getLogger(__name__)
+
+# This file defines user-specific actions that can be performed on ATProtoSocial entities,
+# typically represented as buttons or links in the UI, often on user profiles or posts.
+
+# For ATProtoSocial, actions might include:
+# - Viewing a user's profile on Bluesky/ATProtoSocial instance.
+# - Following/Unfollowing a user.
+# - Muting/Blocking a user.
+# - Reporting a user.
+# - Fetching a user's latest posts.
+
+# These actions are often presented in a context menu or as direct buttons.
+# The `get_user_actions` method in the ATProtoSocialSession class would define these.
+# This file would contain the implementation or further handling logic if needed,
+# or if actions are too complex for simple lambda/method calls in the session class.
+
+# Example structure for defining an action:
+# (This might be more detailed if actions require forms or multi-step processes)
+
+# def view_profile_action(session: ATProtoSocialSession, user_id: str) -> dict[str, Any]:
+#     """
+#     Generates data for a "View Profile on ATProtoSocial" action.
+#     user_id here would be the ATProtoSocial DID or handle.
+#     """
+#     # profile_url = f"https://bsky.app/profile/{user_id}" # Example, construct from handle or DID
+#     # This might involve resolving DID to handle or vice-versa if only one is known.
+#     # handle = await session.util.get_username_from_user_id(user_id) or user_id
+#     # profile_url = f"https://bsky.app/profile/{handle}"
+
+#     return {
+#         "id": "atprotosocial_view_profile",
+#         "label": _("View Profile on Bluesky"),
+#         "icon": "external-link-alt", # FontAwesome icon name
+#         "action_type": "link", # "link", "modal", "api_call"
+#         "url": profile_url, # For "link" type
+#         # "api_endpoint": "/api/atprotosocial/user_action", # For "api_call"
+#         # "payload": {"action": "view_profile", "target_user_id": user_id},
+#         "confirmation_required": False,
+#     }
+
+
+# async def follow_user_action_handler(session: ATProtoSocialSession, target_user_id: str) -> dict[str, Any]:
+#     """
+#     Handles the 'follow_user' action for ATProtoSocial.
+#     target_user_id should be the DID of the user to follow.
+#     """
+#     # success = await session.util.follow_user(target_user_id)
+#     # if success:
+#     #     return {"status": "success", "message": _("User {target_user_id} followed.").format(target_user_id=target_user_id)}
+#     # else:
+#     #     return {"status": "error", "message": _("Failed to follow user {target_user_id}.").format(target_user_id=target_user_id)}
+#     return {"status": "pending", "message": "Follow action not implemented yet."}
+
+
+# The list of available actions is typically defined in the Session class,
+# e.g., ATProtoSocialSession.get_user_actions(). That method would return a list
+# of dictionaries, and this file might provide handlers for more complex actions
+# if they aren't simple API calls defined directly in the session's util.
+
+# For now, this file can be a placeholder if most actions are simple enough
+# to be handled directly by the session.util methods or basic handler routes.
+
+logger.info("ATProtoSocial userActions module loaded (placeholders).")