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/__init__.py

@@ -0,0 +1,3 @@
+from .handler import Handler
+
+__all__ = ["Handler"]

src/controller/atprotosocial/handler.py

@@ -0,0 +1,489 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+fromapprove.controller.base import BaseHandler
+fromapprove.sessions import SessionStoreInterface
+
+if TYPE_CHECKING:
+    fromapprove.config import Config
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+
+logger = logging.getLogger(__name__)
+
+
+class Handler(BaseHandler):
+    SESSION_KIND = "atprotosocial"
+
+    def __init__(self, session_store: SessionStoreInterface, config: Config) -> None:
+        super().__init__(session_store, config)
+        self.main_controller = wx.GetApp().mainController # Get a reference to the mainController
+        # Define menu labels specific to ATProtoSocial
+        self.menus = {
+            "menubar_item": _("&Post"),  # Top-level menu for posting actions
+            "compose": _("&New Post"),   # New post/skeet
+            "share": _("&Repost"),       # Equivalent of Boost/Retweet
+            "fav": _("&Like"),           # Equivalent of Favorite
+            "unfav": _("&Unlike"),
+            # "dm": None,  # Disable Direct Message if not applicable
+            # Add other menu items that need relabeling or enabling/disabling
+        }
+        # self.item_menu is another attribute used in mainController.update_menus
+        # It seems to be the label for the second main menu (originally "&Tweet")
+        self.item_menu = _("&Post") # Changes the top-level "Tweet" menu label to "Post"
+
+    def _get_session(self, user_id: str) -> ATProtoSocialSession:
+        session = self.session_store.get_session_by_user_id(user_id, self.SESSION_KIND)
+        if not session:
+            # It's possible the session is still being created, especially during initial setup.
+            # Try to get it from the global sessions store if it was just added.
+            from sessions import sessions as global_sessions
+            if user_id in global_sessions and global_sessions[user_id].KIND == self.SESSION_KIND:
+                return global_sessions[user_id] # type: ignore[return-value]
+            raise ValueError(f"No ATProtoSocial session found for user {user_id}")
+        return session # type: ignore[return-value] # We are checking kind
+
+    def create_buffers(self, user_id: str) -> None:
+        """Creates the default set of buffers for an ATProtoSocial session."""
+        session = self._get_session(user_id)
+        if not session:
+            logger.error(f"Cannot create buffers for ATProtoSocial user {user_id}: session not found.")
+            return
+
+        logger.info(f"Creating default buffers for ATProtoSocial user {user_id} ({session.label})")
+
+        # Home Timeline Buffer
+        self.main_controller.add_buffer(
+            buffer_type="home_timeline", # Generic type, panel will adapt based on session kind
+            user_id=user_id,
+            name=_("{label} Home").format(label=session.label),
+            session_kind=self.SESSION_KIND 
+        )
+
+        # Notifications Buffer
+        self.main_controller.add_buffer(
+            buffer_type="notifications", # Generic type
+            user_id=user_id,
+            name=_("{label} Notifications").format(label=session.label),
+            session_kind=self.SESSION_KIND
+        )
+        
+        # Own Posts (Profile) Buffer - using "user_posts" which is often generic
+        # self.main_controller.add_buffer(
+        #     buffer_type="user_posts", 
+        #     user_id=user_id, # User whose posts to show (self in this case)
+        #     target_user_id=session.util.get_own_did(), # Pass own DID as target
+        #     name=_("{label} My Posts").format(label=session.label),
+        #     session_kind=self.SESSION_KIND
+        # )
+        # Mentions buffer might be part of notifications or a separate stream/filter later.
+
+        # Ensure these buffers are shown if it's a new setup
+        # This part might be handled by mainController.add_buffer or session startup logic
+        # For now, just creating them. The UI should make them visible.
+
+    # --- Action Handlers (called by mainController based on menu interactions) ---
+
+    async def repost_item(self, session: ATProtoSocialSession, item_uri: str) -> dict[str, Any]:
+        """Handles reposting an item."""
+        if not session.is_ready():
+            return {"status": "error", "message": _("Session not ready.")}
+        try:
+            success = await session.util.repost_post(item_uri) # Assuming repost_post in utils
+            if success:
+                return {"status": "success", "message": _("Post reposted successfully.")}
+            else:
+                return {"status": "error", "message": _("Failed to repost post.")}
+        except NotificationError as e:
+            return {"status": "error", "message": e.message}
+        except Exception as e:
+            logger.error(f"Error reposting item {item_uri}: {e}", exc_info=True)
+            return {"status": "error", "message": _("An unexpected error occurred while reposting.")}
+
+    async def like_item(self, session: ATProtoSocialSession, item_uri: str) -> dict[str, Any]:
+        """Handles liking an item."""
+        if not session.is_ready():
+            return {"status": "error", "message": _("Session not ready.")}
+        try:
+            like_uri = await session.util.like_post(item_uri) # Assuming like_post in utils
+            if like_uri:
+                return {"status": "success", "message": _("Post liked successfully."), "like_uri": like_uri}
+            else:
+                return {"status": "error", "message": _("Failed to like post.")}
+        except NotificationError as e:
+            return {"status": "error", "message": e.message}
+        except Exception as e:
+            logger.error(f"Error liking item {item_uri}: {e}", exc_info=True)
+            return {"status": "error", "message": _("An unexpected error occurred while liking the post.")}
+
+    async def unlike_item(self, session: ATProtoSocialSession, like_uri: str) -> dict[str, Any]: # like_uri is the URI of the like record
+        """Handles unliking an item."""
+        if not session.is_ready():
+            return {"status": "error", "message": _("Session not ready.")}
+        try:
+            # Unlike typically requires the URI of the like record itself, not the post.
+            # The UI or calling context needs to store this (e.g. from viewer_state of the post).
+            success = await session.util.delete_like(like_uri) # Assuming delete_like in utils
+            if success:
+                return {"status": "success", "message": _("Like removed successfully.")}
+            else:
+                return {"status": "error", "message": _("Failed to remove like.")}
+        except NotificationError as e:
+            return {"status": "error", "message": e.message}
+        except Exception as e:
+            logger.error(f"Error unliking item with like URI {like_uri}: {e}", exc_info=True)
+            return {"status": "error", "message": _("An unexpected error occurred while unliking.")}
+
+
+    async def handle_action(self, action_name: str, user_id: str, payload: dict[str, Any]) -> dict[str, Any] | None:
+        """Handles actions specific to ATProtoSocial integration."""
+        logger.debug(
+            f"Handling ATProtoSocial action '{action_name}' for user {user_id} with payload: {payload}"
+        )
+        # session = self._get_session(user_id)
+
+        # TODO: Implement action handlers based on ATProtoSocial's capabilities
+        # Example:
+        # if action_name == "get_profile_info":
+        #     # profile_data = await session.util.get_profile_info(payload.get("handle"))
+        #     # return {"profile": profile_data}
+        # elif action_name == "follow_user":
+        #     # await session.util.follow_user(payload.get("user_id_to_follow"))
+        #     # return {"status": "success", "message": "User followed"}
+        # else:
+        #     logger.warning(f"Unknown ATProtoSocial action: {action_name}")
+        #     return {"error": f"Unknown action: {action_name}"}
+        return None # Placeholder
+
+    async def handle_message_command(
+        self, command: str, user_id: str, message_id: str, payload: dict[str, Any]
+    ) -> dict[str, Any] | None:
+        """Handles commands related to specific messages for ATProtoSocial."""
+        logger.debug(
+            f"Handling ATProtoSocial message command '{command}' for user {user_id}, message {message_id} with payload: {payload}"
+        )
+        # session = self._get_session(user_id)
+
+        # TODO: Implement message command handlers
+        # Example:
+        # if command == "get_post_details":
+        #     # post_details = await session.util.get_post_by_id(message_id)
+        #     # return {"details": post_details}
+        # elif command == "like_post":
+        #     # await session.util.like_post(message_id)
+        #     # return {"status": "success", "message": "Post liked"}
+        # else:
+        #     logger.warning(f"Unknown ATProtoSocial message command: {command}")
+        #     return {"error": f"Unknown message command: {command}"}
+        return None # Placeholder
+
+fromapprove.translation import translate as _ # For user-facing messages
+
+    async def handle_user_command(
+        self, command: str, user_id: str, target_user_id: str, payload: dict[str, Any]
+    ) -> dict[str, Any] | None:
+        """Handles commands related to specific users for ATProtoSocial."""
+        logger.debug(
+            f"Handling ATProtoSocial user command '{command}' for user {user_id}, target user {target_user_id} with payload: {payload}"
+        )
+        session = self._get_session(user_id)
+        if not session.is_ready():
+            return {"status": "error", "message": _("ATProtoSocial session is not active or authenticated.")}
+
+        # target_user_id is expected to be the DID of the user to act upon.
+        if not target_user_id:
+            return {"status": "error", "message": _("Target user DID not provided.")}
+
+        success = False
+        message = _("Action could not be completed.") # Default error message
+
+        try:
+            if command == "follow_user":
+                success = await session.util.follow_user(target_user_id)
+                message = _("User followed successfully.") if success else _("Failed to follow user.")
+            elif command == "unfollow_user":
+                success = await session.util.unfollow_user(target_user_id)
+                message = _("User unfollowed successfully.") if success else _("Failed to unfollow user.")
+            elif command == "mute_user":
+                success = await session.util.mute_user(target_user_id)
+                message = _("User muted successfully.") if success else _("Failed to mute user.")
+            elif command == "unmute_user":
+                success = await session.util.unmute_user(target_user_id)
+                message = _("User unmuted successfully.") if success else _("Failed to unmute user.")
+            elif command == "block_user":
+                block_uri = await session.util.block_user(target_user_id) # Returns URI or None
+                success = bool(block_uri)
+                message = _("User blocked successfully.") if success else _("Failed to block user.")
+            elif command == "unblock_user":
+                success = await session.util.unblock_user(target_user_id)
+                message = _("User unblocked successfully.") if success else _("Failed to unblock user, or user was not blocked.")
+            else:
+                logger.warning(f"Unknown ATProtoSocial user command: {command}")
+                return {"status": "error", "message": _("Unknown action: {command}").format(command=command)}
+            
+            return {"status": "success" if success else "error", "message": message}
+
+        except NotificationError as e: # Catch specific errors raised from utils
+            logger.error(f"ATProtoSocial user command '{command}' failed for target {target_user_id}: {e.message}")
+            return {"status": "error", "message": e.message}
+        except Exception as e:
+            logger.error(f"Unexpected error during ATProtoSocial user command '{command}' for target {target_user_id}: {e}", exc_info=True)
+            return {"status": "error", "message": _("An unexpected server error occurred.")}
+
+    # --- UI Related Action Handlers (called by mainController) ---
+
+    async def user_details(self, buffer: Any) -> None: # buffer is typically a timeline panel
+        """Shows user profile details for the selected user in the buffer."""
+        session = buffer.session
+        if not session or session.KIND != self.SESSION_KIND or not session.is_ready():
+            output.speak(_("Active ATProtoSocial session not found or not ready."), True)
+            return
+
+        user_ident = None
+        if hasattr(buffer, "get_selected_item_author_details"): # Method in panel to get author of selected post
+            author_details = buffer.get_selected_item_author_details()
+            if author_details and isinstance(author_details, dict):
+                user_ident = author_details.get("did") or author_details.get("handle")
+        
+        if not user_ident:
+            # Fallback or if no item selected, prompt for user
+            # For now, just inform user if no selection. A dialog prompt could be added.
+            output.speak(_("Please select an item or user to view details."), True)
+            # TODO: Add wx.TextEntryDialog to ask for user handle/DID if none selected
+            return
+
+        try:
+            profile_data = await session.util.get_user_profile(user_ident)
+            if profile_data:
+                # TODO: Integrate with a wx dialog for displaying profile.
+                # For now, show a simple message box with some details.
+                # Example: from src.wxUI.dialogs.mastodon.showUserProfile import UserProfileDialog
+                # profile_dialog = UserProfileDialog(self.main_controller.view, session, profile_data_dict)
+                # profile_dialog.Show()
+                formatted_info = f"User: {profile_data.displayName} (@{profile_data.handle})\n"
+                formatted_info += f"DID: {profile_data.did}\n"
+                formatted_info += f"Followers: {profile_data.followersCount or 0}\n"
+                formatted_info += f"Following: {profile_data.followsCount or 0}\n"
+                formatted_info += f"Posts: {profile_data.postsCount or 0}\n"
+                formatted_info += f"Bio: {profile_data.description or ''}"
+                wx.MessageBox(formatted_info, _("User Profile (ATProtoSocial)"), wx.OK | wx.ICON_INFORMATION, self.main_controller.view)
+            else:
+                output.speak(_("Could not fetch profile for {user_ident}.").format(user_ident=user_ident), True)
+        except Exception as e:
+            logger.error(f"Error fetching/displaying profile for {user_ident}: {e}", exc_info=True)
+            output.speak(_("Error displaying profile: {error}").format(error=str(e)), True)
+
+
+    async def open_user_timeline(self, main_controller: Any, session: ATProtoSocialSession, user_payload: Any | None) -> None:
+        """Opens a new buffer for a specific user's posts."""
+        user_ident = None
+        if isinstance(user_payload, dict): # Assuming user_payload is a dict from get_selected_item_author_details
+            user_ident = user_payload.get("did") or user_payload.get("handle")
+        elif isinstance(user_payload, str): # Direct DID or Handle string
+            user_ident = user_payload
+
+        if not user_ident: # Prompt if not found
+            dialog = wx.TextEntryDialog(main_controller.view, _("Enter user DID or handle:"), _("View User Timeline"))
+            if dialog.ShowModal() == wx.ID_OK:
+                user_ident = dialog.GetValue()
+            dialog.Destroy()
+            if not user_ident:
+                return
+
+        # Fetch profile to get canonical handle/DID for buffer name, and to ensure user exists
+        try:
+            profile = await session.util.get_user_profile(user_ident)
+            if not profile:
+                output.speak(_("User {user_ident} not found.").format(user_ident=user_ident), True)
+                return
+            
+            buffer_name = _("{user_handle}'s Posts").format(user_handle=profile.handle)
+            buffer_id = f"atp_user_feed_{profile.did}" # Unique ID for the buffer
+
+            # Check if buffer already exists
+            # existing_buffer = main_controller.search_buffer_by_id_or_properties(id=buffer_id) # Hypothetical method
+            # For now, assume it might create duplicates if not handled by add_buffer logic
+            
+            main_controller.add_buffer(
+                buffer_type="user_timeline", # This type will need a corresponding panel
+                user_id=session.uid, # The session user_id
+                name=buffer_name,
+                session_kind=self.SESSION_KIND,
+                target_user_did=profile.did, # Store target DID for the panel to use
+                target_user_handle=profile.handle
+            )
+        except Exception as e:
+            logger.error(f"Error opening user timeline for {user_ident}: {e}", exc_info=True)
+            output.speak(_("Failed to open user timeline: {error}").format(error=str(e)), True)
+
+
+    async def open_followers_timeline(self, main_controller: Any, session: ATProtoSocialSession, user_payload: Any | None) -> None:
+        """Opens a new buffer for a user's followers."""
+        user_ident = None
+        if isinstance(user_payload, dict):
+            user_ident = user_payload.get("did") or user_payload.get("handle")
+        elif isinstance(user_payload, str):
+            user_ident = user_payload
+
+        if not user_ident:
+            dialog = wx.TextEntryDialog(main_controller.view, _("Enter user DID or handle to view followers:"), _("View Followers"))
+            if dialog.ShowModal() == wx.ID_OK:
+                user_ident = dialog.GetValue()
+            dialog.Destroy()
+            if not user_ident:
+                return
+        
+        try:
+            profile = await session.util.get_user_profile(user_ident) # Ensure user exists, get DID
+            if not profile:
+                output.speak(_("User {user_ident} not found.").format(user_ident=user_ident), True)
+                return
+
+            buffer_name = _("Followers of {user_handle}").format(user_handle=profile.handle)
+            main_controller.add_buffer(
+                buffer_type="user_list_followers", # Needs specific panel type
+                user_id=session.uid,
+                name=buffer_name,
+                session_kind=self.SESSION_KIND,
+                target_user_did=profile.did
+            )
+        except Exception as e:
+            logger.error(f"Error opening followers list for {user_ident}: {e}", exc_info=True)
+            output.speak(_("Failed to open followers list: {error}").format(error=str(e)), True)
+
+
+    async def open_following_timeline(self, main_controller: Any, session: ATProtoSocialSession, user_payload: Any | None) -> None:
+        """Opens a new buffer for users a user is following."""
+        user_ident = None
+        if isinstance(user_payload, dict):
+            user_ident = user_payload.get("did") or user_payload.get("handle")
+        elif isinstance(user_payload, str):
+            user_ident = user_payload
+
+        if not user_ident:
+            dialog = wx.TextEntryDialog(main_controller.view, _("Enter user DID or handle to view their following list:"), _("View Following"))
+            if dialog.ShowModal() == wx.ID_OK:
+                user_ident = dialog.GetValue()
+            dialog.Destroy()
+            if not user_ident:
+                return
+
+        try:
+            profile = await session.util.get_user_profile(user_ident) # Ensure user exists, get DID
+            if not profile:
+                output.speak(_("User {user_ident} not found.").format(user_ident=user_ident), True)
+                return
+
+            buffer_name = _("Following by {user_handle}").format(user_handle=profile.handle)
+            main_controller.add_buffer(
+                buffer_type="user_list_following", # Needs specific panel type
+                user_id=session.uid,
+                name=buffer_name,
+                session_kind=self.SESSION_KIND,
+                target_user_did=profile.did
+            )
+        except Exception as e:
+            logger.error(f"Error opening following list for {user_ident}: {e}", exc_info=True)
+            output.speak(_("Failed to open following list: {error}").format(error=str(e)), True)
+
+
+    async def get_settings_inputs(self, user_id: str | None = None) -> list[dict[str, Any]]:
+        """Returns settings inputs for ATProtoSocial, potentially user-specific."""
+        # This typically delegates to the Session class's method
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        
+        current_config = {}
+        if user_id:
+            # Fetch existing config for the user if available to pre-fill values
+            # This part depends on how config is stored and accessed.
+            # For example, if Session class has a method to get its current config:
+            try:
+                session = self._get_session(user_id)
+                current_config = session.get_configurable_values_for_user(user_id)
+            except ValueError: # No session means no specific config yet for this user
+                pass
+            except Exception as e:
+                logger.error(f"Error fetching current ATProtoSocial config for user {user_id}: {e}")
+
+
+        return ATProtoSocialSession.get_settings_inputs(user_id=user_id, current_config=current_config)
+
+    async def update_settings(self, user_id: str, settings_data: dict[str, Any]) -> dict[str, Any]:
+        """Updates settings for ATProtoSocial for a given user."""
+        logger.info(f"Updating ATProtoSocial settings for user {user_id}")
+        
+        # This is a simplified example. In a real scenario, you'd validate `settings_data`
+        # and then update the configuration, possibly re-initializing the session or
+        # informing it of the changes.
+        
+        # config_manager = self.config.sessions.atprotosocial[user_id]
+        # for key, value in settings_data.items():
+        #     if hasattr(config_manager, key):
+        #         await config_manager[key].set(value)
+        #     else:
+        #         logger.warning(f"Attempted to set unknown ATProtoSocial setting '{key}' for user {user_id}")
+
+        # # Optionally, re-initialize or notify the session if it's active
+        # try:
+        #     session = self._get_session(user_id)
+        #     await session.stop() # Stop if it might be using old settings
+        #     # Re-fetch config for the session or update it directly
+        #     # session.api_base_url = settings_data.get("api_base_url", session.api_base_url) 
+        #     # session.access_token = settings_data.get("access_token", session.access_token)
+        #     if session.active: # Or based on some logic if it should auto-restart
+        #         await session.start()
+        #     logger.info(f"Successfully updated and re-initialized ATProtoSocial session for user {user_id}")
+        # except ValueError:
+        #     logger.info(f"ATProtoSocial session for user {user_id} not found or not active, settings saved but session not restarted.")
+        # except Exception as e:
+        #     logger.error(f"Error re-initializing ATProtoSocial session for user {user_id} after settings update: {e}")
+        #     return {"status": "error", "message": f"Settings saved, but failed to restart session: {e}"}
+
+        # For now, just a placeholder response
+        return {"status": "success", "message": "ATProtoSocial settings updated (implementation pending)."}
+
+    @classmethod
+    def get_auth_inputs(cls, user_id: str | None = None) -> list[dict[str, Any]]:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        # current_config = {} # fetch if needed
+        return ATProtoSocialSession.get_auth_inputs(user_id=user_id) # current_config=current_config
+
+    @classmethod
+    async def test_connection(cls, settings: dict[str, Any]) -> tuple[bool, str]:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return await ATProtoSocialSession.test_connection(settings)
+
+    @classmethod
+    def get_user_actions(cls) -> list[dict[str, Any]]:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return ATProtoSocialSession.get_user_actions()
+
+    @classmethod
+    def get_user_list_actions(cls) -> list[dict[str, Any]]:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return ATProtoSocialSession.get_user_list_actions()
+
+    @classmethod
+    def get_config_description(cls) -> str | None:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return ATProtoSocialSession.get_config_description()
+
+    @classmethod
+    def get_auth_type(cls) -> str:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return ATProtoSocialSession.get_auth_type()
+
+    @classmethod
+    def get_logo_path(cls) -> str | None:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return ATProtoSocialSession.get_logo_path()
+
+    @classmethod
+    def get_session_kind(cls) -> str:
+        return cls.SESSION_KIND
+
+    @classmethod
+    def get_dependencies(cls) -> list[str]:
+        fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+        return ATProtoSocialSession.get_dependencies()

src/controller/atprotosocial/messages.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+# fromapprove.controller.mastodon import messages as mastodon_messages # Example, if adapting
+fromapprove.translation import translate as _
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession # Adjusted import
+
+logger = logging.getLogger(__name__)
+
+# This file would typically contain functions to generate complex message bodies or
+# interactive components for ATProtoSocial, similar to how it might be done for Mastodon.
+# Since ATProtoSocial's interactive features (beyond basic posts) are still evolving
+# or client-dependent (like polls), this might be less complex initially.
+
+# Example: If ATProtoSocial develops a standard for "cards" or interactive messages,
+# functions to create those would go here. For now, we can imagine placeholders.
+
+def format_welcome_message(session: ATProtoSocialSession) -> dict[str, Any]:
+    """
+    Generates a welcome message for a new ATProtoSocial session.
+    This is just a placeholder and example.
+    """
+    # user_profile = session.util.get_own_profile_info() # Assuming this method exists and is async or cached
+    # handle = user_profile.get("handle", _("your ATProtoSocial account")) if user_profile else _("your ATProtoSocial account")
+    handle = session.util.get_own_username() or _("your ATProtoSocial account")
+
+
+    return {
+        "text": _("Welcome to Approve for ATProtoSocial! Your account {handle} is connected.").format(handle=handle),
+        # "blocks": [ # If ATProtoSocial supports a block kit like Slack or Discord
+        #     {
+        #         "type": "section",
+        #         "text": {
+        #             "type": "mrkdwn", # Or ATProtoSocial's equivalent
+        #             "text": _("Welcome to Approve for ATProtoSocial! Your account *{handle}* is connected.").format(handle=handle)
+        #         }
+        #     },
+        #     {
+        #         "type": "actions",
+        #         "elements": [
+        #             {
+        #                 "type": "button",
+        #                 "text": {"type": "plain_text", "text": _("Post your first Skeet")},
+        #                 "action_id": "atprotosocial_compose_new_post" # Example action ID
+        #             }
+        #         ]
+        #     }
+        # ]
+    }
+
+def format_error_message(error_description: str, details: str | None = None) -> dict[str, Any]:
+    """
+    Generates a standardized error message.
+    """
+    message = {"text": f":warning: Error: {error_description}"} # Basic text message
+    # if details:
+    #     message["blocks"] = [
+    #         {
+    #             "type": "section",
+    #             "text": {"type": "mrkdwn", "text": f":warning: *Error:* {error_description}\n{details}"}
+    #         }
+    #     ]
+    return message
+
+# More functions could be added here as ATProtoSocial's capabilities become clearer
+# or as specific formatting needs for Approve arise. For example:
+# - Formatting a post for display with all its embeds and cards.
+# - Generating help messages specific to ATProtoSocial features.
+# - Creating interactive messages for polls (if supported via some convention).
+
+# Example of adapting a function that might exist in mastodon_messages:
+# def build_post_summary_message(session: ATProtoSocialSession, post_uri: str, post_content: dict) -> dict[str, Any]:
+#     """
+#     Builds a summary message for an ATProtoSocial post.
+#     """
+#     author_handle = post_content.get("author", {}).get("handle", "Unknown user")
+#     text_preview = post_content.get("text", "")[:100] # First 100 chars of text
+#     # url = session.get_message_url(post_uri) # Assuming this method exists
+#     url = f"https://bsky.app/profile/{author_handle}/post/{post_uri.split('/')[-1]}" # Construct a URL
+
+#     return {
+#         "text": _("Post by {author_handle}: {text_preview}... ({url})").format(
+#             author_handle=author_handle, text_preview=text_preview, url=url
+#         ),
+#         # Potentially with "blocks" for richer formatting if the platform supports it
+#     }
+
+logger.info("ATProtoSocial messages module loaded (placeholders).")

src/controller/atprotosocial/settings.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+fromapprove.forms import Form, SubmitField, TextAreaField, TextField
+fromapprove.translation import translate as _
+
+if TYPE_CHECKING:
+    fromapprove.config import ConfigSectionProxy
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession # Adjusted
+
+logger = logging.getLogger(__name__)
+
+# This file is for defining forms and handling for ATProtoSocial-specific settings
+# that might be more complex than simple key-value pairs handled by Session.get_settings_inputs.
+# For ATProtoSocial, initial settings might be simple (handle, app password),
+# but this structure allows for expansion.
+
+
+class ATProtoSocialSettingsForm(Form):
+    """
+    A settings form for ATProtoSocial sessions.
+    This would mirror the kind of settings found in Session.get_settings_inputs
+    but using the WTForms-like Form structure for more complex validation or layout.
+    """
+    # Example fields - these should align with what ATProtoSocialSession.get_settings_inputs defines
+    # and what ATProtoSocialSession.get_configurable_values expects for its config.
+    
+    # instance_url = TextField(
+    #     _("Instance URL"),
+    #     default="https://bsky.social", # Default PDS for Bluesky
+    #     description=_("The base URL of your ATProtoSocial PDS instance (e.g., https://bsky.social)."),
+    #     validators=[], # Add validators if needed, e.g., URL validator
+    # )
+    handle = TextField(
+        _("Bluesky Handle"),
+        description=_("Your Bluesky user handle (e.g., @username.bsky.social or username.bsky.social)."),
+        validators=[], # e.g., DataRequired()
+    )
+    app_password = TextField( # Consider PasswordField if sensitive and your Form class supports it
+        _("App Password"),
+        description=_("Your Bluesky App Password. Generate this in your Bluesky account settings."),
+        validators=[], # e.g., DataRequired()
+    )
+    # Add more fields as needed for ATProtoSocial configuration.
+    # For example, if there were specific notification settings, content filters, etc.
+    
+    submit = SubmitField(_("Save ATProtoSocial Settings"))
+
+
+async def get_settings_form(
+    user_id: str,
+    session: ATProtoSocialSession | None = None,
+    config: ConfigSectionProxy | None = None, # User-specific config for ATProtoSocial
+) -> ATProtoSocialSettingsForm:
+    """
+    Creates and pre-populates the ATProtoSocial settings form.
+    """
+    form_data = {}
+    if session: # If a session exists, use its current config
+        # form_data["instance_url"] = session.config_get("api_base_url", "https://bsky.social")
+        form_data["handle"] = session.config_get("handle", "")
+        # App password should not be pre-filled for security.
+        form_data["app_password"] = "" 
+    elif config: # Fallback to persisted config if no active session
+        # form_data["instance_url"] = config.api_base_url.get("https://bsky.social")
+        form_data["handle"] = config.handle.get("")
+        form_data["app_password"] = ""
+
+    form = ATProtoSocialSettingsForm(formdata=None, **form_data) # formdata=None for initial display
+    return form
+
+
+async def process_settings_form(
+    form: ATProtoSocialSettingsForm,
+    user_id: str,
+    session: ATProtoSocialSession | None = None, # Pass if update should affect live session
+    config: ConfigSectionProxy | None = None, # User-specific config for ATProtoSocial
+) -> bool:
+    """
+    Processes the submitted ATProtoSocial settings form and updates configuration.
+    Returns True if successful, False otherwise.
+    """
+    if not form.validate(): # Assuming form has a validate method
+        logger.warning(f"ATProtoSocial settings form validation failed for user {user_id}: {form.errors}")
+        return False
+
+    if not config and session: # Try to get config via session if not directly provided
+        # This depends on how ConfigSectionProxy is obtained.
+        # config = approve.config.config.sessions.atprotosocial[user_id] # Example path
+        pass # Needs actual way to get config proxy
+
+    if not config:
+        logger.error(f"Cannot process ATProtoSocial settings for user {user_id}: no config proxy available.")
+        return False
+
+    try:
+        # Update the configuration values
+        # await config.api_base_url.set(form.instance_url.data)
+        await config.handle.set(form.handle.data)
+        await config.app_password.set(form.app_password.data) # Ensure this is stored securely
+
+        logger.info(f"ATProtoSocial settings updated for user {user_id}.")
+
+        # If there's an active session, it might need to be reconfigured or restarted
+        if session:
+            logger.info(f"Requesting ATProtoSocial session re-initialization for user {user_id} due to settings change.")
+            # await session.stop() # Stop it
+            # # Update session instance with new values directly or rely on it re-reading config
+            # session.api_base_url = form.instance_url.data
+            # session.handle = form.handle.data 
+            # # App password should be handled carefully, session might need to re-login
+            # await session.start() # Restart with new settings
+            # Or, more simply, the session might have a reconfigure method:
+            # await session.reconfigure(new_settings_dict)
+            pass # Placeholder for session reconfiguration logic
+
+        return True
+    except Exception as e:
+        logger.error(f"Error saving ATProtoSocial settings for user {user_id}: {e}", exc_info=True)
+        return False
+
+# Any additional ATProtoSocial-specific settings views or handlers would go here.
+# For instance, if ATProtoSocial had features like "Relays" or "Feed Generators"
+# that needed UI configuration within Approve, those forms and handlers could be defined here.
+
+logger.info("ATProtoSocial settings module loaded (placeholders).")

src/controller/atprotosocial/templateEditor.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+# fromapprove.controller.mastodon import templateEditor as mastodon_template_editor # If adapting
+fromapprove.translation import translate as _
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession # Adjusted
+
+logger = logging.getLogger(__name__)
+
+# This file would handle the logic for a template editor specific to ATProtoSocial.
+# A template editor allows users to customize how certain information or messages
+# from ATProtoSocial are displayed in Approve.
+
+# For ATProtoSocial, this might be less relevant initially if its content structure
+# is simpler than Mastodon's, or if user-customizable templates are not a primary feature.
+# However, having the structure allows for future expansion.
+
+# Example: Customizing the format of a "new follower" notification, or how a "skeet" is displayed.
+
+class ATProtoSocialTemplateEditor:
+    def __init__(self, session: ATProtoSocialSession) -> None:
+        self.session = session
+        # self.user_id = session.user_id
+        # self.config_prefix = f"sessions.atprotosocial.{self.user_id}.templates." # Example config path
+
+    def get_editable_templates(self) -> list[dict[str, Any]]:
+        """
+        Returns a list of templates that the user can edit for ATProtoSocial.
+        Each entry should describe the template, its purpose, and current value.
+        """
+        # This would typically fetch template definitions from a default set
+        # and override with any user-customized versions from config.
+        
+        # Example structure for an editable template:
+        # templates = [
+        #     {
+        #         "id": "new_follower_notification", # Unique ID for this template
+        #         "name": _("New Follower Notification Format"),
+        #         "description": _("Customize how new follower notifications from ATProtoSocial are displayed."),
+        #         "default_template": "{{ actor.displayName }} (@{{ actor.handle }}) is now following you on ATProtoSocial!",
+        #         "current_template": self._get_template_content("new_follower_notification"),
+        #         "variables": [ # Available variables for this template
+        #             {"name": "actor.displayName", "description": _("Display name of the new follower")},
+        #             {"name": "actor.handle", "description": _("Handle of the new follower")},
+        #             {"name": "actor.url", "description": _("URL to the new follower's profile")},
+        #         ],
+        #         "category": "notifications", # For grouping in UI
+        #     },
+        #     # Add more editable templates for ATProtoSocial here
+        # ]
+        # return templates
+        return [] # Placeholder - no editable templates defined yet for ATProtoSocial
+
+    def _get_template_content(self, template_id: str) -> str:
+        """
+        Retrieves the current content of a specific template, either user-customized or default.
+        """
+        # config_key = self.config_prefix + template_id
+        # default_value = self._get_default_template_content(template_id)
+        # return approve.config.config.get_value(config_key, default_value) # Example config access
+        return self._get_default_template_content(template_id) # Placeholder
+
+    def _get_default_template_content(self, template_id: str) -> str:
+        """
+        Returns the default content for a given template ID.
+        """
+        # This could be hardcoded or loaded from a defaults file.
+        # if template_id == "new_follower_notification":
+        #     return "{{ actor.displayName }} (@{{ actor.handle }}) is now following you on ATProtoSocial!"
+        # # ... other default templates
+        return "" # Placeholder
+
+    async def save_template_content(self, template_id: str, content: str) -> bool:
+        """
+        Saves the user-customized content for a specific template.
+        """
+        # config_key = self.config_prefix + template_id
+        # try:
+        #     await approve.config.config.set_value(config_key, content) # Example config access
+        #     logger.info(f"ATProtoSocial template '{template_id}' saved for user {self.user_id}.")
+        #     return True
+        # except Exception as e:
+        #     logger.error(f"Error saving ATProtoSocial template '{template_id}' for user {self.user_id}: {e}")
+        #     return False
+        return False # Placeholder
+
+    def get_template_preview(self, template_id: str, custom_content: str | None = None) -> str:
+        """
+        Generates a preview of a template using sample data.
+        If custom_content is provided, it's used instead of the saved template.
+        """
+        # content_to_render = custom_content if custom_content is not None else self._get_template_content(template_id)
+        # sample_data = self._get_sample_data_for_template(template_id)
+        
+        # try:
+        #     # Use a templating engine (like Jinja2) to render the preview
+        #     # from jinja2 import Template
+        #     # template = Template(content_to_render)
+        #     # preview = template.render(**sample_data)
+        #     # return preview
+        #     return f"Preview for '{template_id}': {content_to_render}" # Basic placeholder
+        # except Exception as e:
+        #     logger.error(f"Error generating preview for ATProtoSocial template '{template_id}': {e}")
+        #     return _("Error generating preview.")
+        return _("Template previews not yet implemented for ATProtoSocial.") # Placeholder
+
+    def _get_sample_data_for_template(self, template_id: str) -> dict[str, Any]:
+        """
+        Returns sample data appropriate for previewing a specific template.
+        """
+        # if template_id == "new_follower_notification":
+        #     return {
+        #         "actor": {
+        #             "displayName": "Test User",
+        #             "handle": "testuser.bsky.social",
+        #             "url": "https://bsky.app/profile/testuser.bsky.social"
+        #         }
+        #     }
+        # # ... other sample data
+        return {} # Placeholder
+
+# Functions to be called by the main controller/handler for template editor actions.
+
+async def get_editor_config(session: ATProtoSocialSession) -> dict[str, Any]:
+    """
+    Get the configuration needed to display the template editor for ATProtoSocial.
+    """
+    editor = ATProtoSocialTemplateEditor(session)
+    return {
+        "editable_templates": editor.get_editable_templates(),
+        "help_text": _("Customize ATProtoSocial message formats. Use variables shown for each template."),
+    }
+
+async def save_template(session: ATProtoSocialSession, template_id: str, content: str) -> bool:
+    """
+    Save a modified template for ATProtoSocial.
+    """
+    editor = ATProtoSocialTemplateEditor(session)
+    return await editor.save_template_content(template_id, content)
+
+async def get_template_preview_html(session: ATProtoSocialSession, template_id: str, content: str) -> str:
+    """
+    Get an HTML preview for a template with given content.
+    """
+    editor = ATProtoSocialTemplateEditor(session)
+    return editor.get_template_preview(template_id, custom_content=content)
+
+
+logger.info("ATProtoSocial template editor module loaded (placeholders).")

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).")

src/controller/atprotosocial/userList.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, AsyncGenerator
+
+fromapprove.translation import translate as _
+# fromapprove.controller.mastodon import userList as mastodon_user_list # If adapting
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession # Adjusted
+    # Define a type for what a user entry in a list might look like for ATProtoSocial
+    ATProtoSocialUserListItem = dict[str, Any] # e.g. {"did": "...", "handle": "...", "displayName": "..."}
+
+logger = logging.getLogger(__name__)
+
+# This file is responsible for fetching and managing lists of users from ATProtoSocial.
+# Examples include:
+# - Followers of a user
+# - Users a user is following
+# - Users who liked or reposted a post
+# - Users in a specific list or feed (if ATProtoSocial supports user lists like Twitter/Mastodon)
+# - Search results for users
+
+# The structure will likely involve:
+# - A base class or functions for paginating through user lists from the ATProtoSocial API.
+# - Specific functions for each type of user list.
+# - Formatting ATProtoSocial user data into a consistent structure for UI display.
+
+async def fetch_followers(
+    session: ATProtoSocialSession,
+    user_id: str, # DID of the user whose followers to fetch
+    limit: int = 20,
+    cursor: str | None = None
+) -> AsyncGenerator[ATProtoSocialUserListItem, None]:
+    """
+    Asynchronously fetches a list of followers for a given ATProtoSocial user.
+    user_id is the DID of the target user.
+    Yields user data dictionaries.
+    """
+    # client = await session.util._get_client() # Get authenticated client
+    # if not client:
+    #     logger.warning(f"ATProtoSocial client not available for fetching followers of {user_id}.")
+    #     return
+
+    # current_cursor = cursor
+    # try:
+    #     while True:
+    #         # response = await client.app.bsky.graph.get_followers(
+    #         #     models.AppBskyGraphGetFollowers.Params(
+    #         #         actor=user_id,
+    #         #         limit=min(limit, 100), # ATProto API might have its own max limit per request (e.g. 100)
+    #         #         cursor=current_cursor
+    #         #     )
+    #         # )
+    #         # if not response or not response.followers:
+    #         #     break
+            
+    #         # for user_profile_view in response.followers:
+    #         #     yield session.util._format_profile_data(user_profile_view) # Use a utility to standardize format
+
+    #         # current_cursor = response.cursor
+    #         # if not current_cursor or len(response.followers) < limit : # Or however the API indicates end of list
+    #         #     break
+            
+    #         # This is a placeholder loop for demonstration
+    #         if current_cursor == "simulated_end_cursor": break # Stop after one simulated page
+    #         for i in range(limit):
+    #             if current_cursor and int(current_cursor) + i >= 25: # Simulate total 25 followers
+    #                 current_cursor = "simulated_end_cursor"
+    #                 break
+    #             yield {
+    #                 "did": f"did:plc:follower{i + (int(current_cursor) if current_cursor else 0)}",
+    #                 "handle": f"follower{i + (int(current_cursor) if current_cursor else 0)}.bsky.social",
+    #                 "displayName": f"Follower {i + (int(current_cursor) if current_cursor else 0)}",
+    #                 "avatar": None # Placeholder
+    #             }
+    #         if not current_cursor: current_cursor = str(limit) # Simulate next cursor
+    #         elif current_cursor != "simulated_end_cursor": current_cursor = str(int(current_cursor) + limit)
+
+
+    """
+    if not session.is_ready():
+        logger.warning(f"Cannot fetch followers for {user_id}: ATProtoSocial session not ready.")
+        # yield {} # Stop iteration if not ready
+        return
+        
+    try:
+        followers_data = await session.util.get_followers(user_did=user_id, limit=limit, cursor=cursor)
+        if followers_data:
+            users, _ = followers_data # We'll return the cursor separately via the calling HTTP handler
+            for user_profile_view in users:
+                yield session.util._format_profile_data(user_profile_view)
+        else:
+            logger.info(f"No followers data returned for user {user_id}.")
+            
+    except Exception as e:
+        logger.error(f"Error in fetch_followers for ATProtoSocial user {user_id}: {e}", exc_info=True)
+        # Depending on desired error handling, could raise or yield an error marker
+
+
+async def fetch_following(
+    session: ATProtoSocialSession,
+    user_id: str, # DID of the user whose followed accounts to fetch
+    limit: int = 20,
+    cursor: str | None = None
+) -> AsyncGenerator[ATProtoSocialUserListItem, None]:
+    """
+    Asynchronously fetches a list of users followed by a given ATProtoSocial user.
+    Yields user data dictionaries.
+    """
+    if not session.is_ready():
+        logger.warning(f"Cannot fetch following for {user_id}: ATProtoSocial session not ready.")
+        return
+
+    try:
+        following_data = await session.util.get_following(user_did=user_id, limit=limit, cursor=cursor)
+        if following_data:
+            users, _ = following_data
+            for user_profile_view in users:
+                yield session.util._format_profile_data(user_profile_view)
+        else:
+            logger.info(f"No following data returned for user {user_id}.")
+            
+    except Exception as e:
+        logger.error(f"Error in fetch_following for ATProtoSocial user {user_id}: {e}", exc_info=True)
+
+
+async def search_users(
+    session: ATProtoSocialSession,
+    query: str,
+    limit: int = 20,
+    cursor: str | None = None 
+) -> AsyncGenerator[ATProtoSocialUserListItem, None]:
+    """
+    Searches for users on ATProtoSocial based on a query string.
+    Yields user data dictionaries.
+    """
+    if not session.is_ready():
+        logger.warning(f"Cannot search users for '{query}': ATProtoSocial session not ready.")
+        return
+
+    try:
+        search_data = await session.util.search_users(term=query, limit=limit, cursor=cursor)
+        if search_data:
+            users, _ = search_data
+            for user_profile_view in users:
+                yield session.util._format_profile_data(user_profile_view)
+        else:
+            logger.info(f"No users found for search term '{query}'.")
+            
+    except Exception as e:
+        logger.error(f"Error in search_users for ATProtoSocial query '{query}': {e}", exc_info=True)
+
+# This function is designed to be called by an API endpoint that returns JSON
+async def get_user_list_paginated(
+    session: ATProtoSocialSession,
+    list_type: str, # "followers", "following", "search"
+    identifier: str, # User DID for followers/following, or search query for search
+    limit: int = 20,
+    cursor: str | None = None
+) -> tuple[list[ATProtoSocialUserListItem], str | None]:
+    """
+    Fetches a paginated list of users (followers, following, or search results)
+    and returns the list and the next cursor.
+    """
+    users_list: list[ATProtoSocialUserListItem] = []
+    next_cursor: str | None = None
+
+    if not session.is_ready():
+        logger.warning(f"Cannot fetch user list '{list_type}': ATProtoSocial session not ready.")
+        return [], None
+
+    try:
+        if list_type == "followers":
+            data = await session.util.get_followers(user_did=identifier, limit=limit, cursor=cursor)
+            if data: users_list = [session.util._format_profile_data(u) for u in data[0]]; next_cursor = data[1]
+        elif list_type == "following":
+            data = await session.util.get_following(user_did=identifier, limit=limit, cursor=cursor)
+            if data: users_list = [session.util._format_profile_data(u) for u in data[0]]; next_cursor = data[1]
+        elif list_type == "search_users":
+            data = await session.util.search_users(term=identifier, limit=limit, cursor=cursor)
+            if data: users_list = [session.util._format_profile_data(u) for u in data[0]]; next_cursor = data[1]
+        else:
+            logger.error(f"Unknown list_type: {list_type}")
+            return [], None
+            
+    except Exception as e:
+        logger.error(f"Error fetching paginated user list '{list_type}' for '{identifier}': {e}", exc_info=True)
+        # Optionally re-raise or return empty with no cursor to indicate error
+        return [], None 
+        
+    return users_list, next_cursor
+
+
+async def get_user_profile_details(session: ATProtoSocialSession, user_ident: str) -> ATProtoSocialUserListItem | None:
+    """
+    Fetches detailed profile information for a user by DID or handle.
+    Returns a dictionary of formatted profile data, or None if not found/error.
+    """
+    if not session.is_ready():
+        logger.warning(f"Cannot get profile for {user_ident}: ATProtoSocial session not ready.")
+        return None
+    
+    try:
+        profile_view_detailed = await session.util.get_user_profile(user_ident=user_ident)
+        if profile_view_detailed:
+            return session.util._format_profile_data(profile_view_detailed)
+        else:
+            logger.info(f"No profile data found for user {user_ident}.")
+            return None
+    except Exception as e:
+        logger.error(f"Error in get_user_profile_details for {user_ident}: {e}", exc_info=True)
+        return None
+
+
+# Other list types could include:
+# - fetch_likers(session, post_uri, limit, cursor) # Needs app.bsky.feed.getLikes
+# - fetch_reposters(session, post_uri, limit, cursor)
+# - fetch_muted_users(session, limit, cursor)
+# - fetch_blocked_users(session, limit, cursor)
+
+# The UI part of Approve that displays user lists would call these functions.
+# Each function needs to handle pagination as provided by the ATProto API (usually cursor-based).
+
+logger.info("ATProtoSocial userList module loaded (placeholders).")

src/controller/mainController.py

@@ -25,6 +25,7 @@ from mysc import localization
 from mysc.thread_utils import call_threaded
 from mysc.repeating_timer import RepeatingTimer
 from controller.mastodon import handler as MastodonHandler
+from controller.atprotosocial import handler as ATProtoSocialHandler # Added import
 from . import settings, userAlias
 
 log = logging.getLogger("mainController")
@@ -194,6 +195,25 @@ class Controller(object):
         if handler == None:
             if type == "mastodon":
                 handler = MastodonHandler.Handler()
+            elif type == "atprotosocial": # Added case for atprotosocial
+                # Assuming session_store and config_proxy are accessible or passed if needed by Handler constructor
+                # For now, let's assume constructor is similar or adapted to not require them,
+                # or that they can be accessed via self if mainController has them.
+                # Based on atprotosocial.Handler, it needs session_store and config.
+                # mainController doesn't seem to store these directly for passing.
+                # This might indicate Handler init needs to be simplified or these need to be plumbed.
+                # For now, proceeding with a simplified instantiation, assuming it can get what it needs
+                # or its __init__ will be adapted.
+                # A common pattern is self.session_store and self.config from a base controller class if mainController inherits one.
+                # Let's assume for now they are not strictly needed for just getting menu labels or simple actions.
+                # This part might need refinement based on Handler's actual dependencies for menu updates.
+                # Looking at atprotosocial/handler.py, it takes session_store and config.
+                # mainController itself doesn't seem to have these as direct attributes to pass on.
+                # This implies a potential refactor need or that these handlers are simpler than thought for menu updates.
+                # For now, let's assume a simplified handler for menu updates or that it gets these elsewhere.
+                # This needs to be compatible with how MastodonHandler is instantiated and used.
+                # MastodonHandler() is called without params here.
+                handler = ATProtoSocialHandler.Handler(session_store=sessions.sessions, config=config.app) # Adjusted: Pass global sessions and config
             self.handlers[type]=handler
         return handler
 
@@ -506,18 +526,74 @@ class Controller(object):
 
     def post_retweet(self, *args, **kwargs):
         buffer = self.get_current_buffer()
-        if hasattr(buffer, "share_item"):
+        if hasattr(buffer, "share_item"): # Generic buffer method
-            return buffer.share_item()
+            return buffer.share_item() # This likely calls back to a session/handler method
+        # If direct handling is needed for ATProtoSocial:
+        elif buffer.session and buffer.session.KIND == "atprotosocial":
+            item_uri = buffer.get_selected_item_id() # Assuming this gets the AT URI
+            if not item_uri:
+                output.speak(_("No item selected to repost."), True)
+                return
+            social_handler = self.get_handler(buffer.session.KIND)
+            async def _repost():
+                result = await social_handler.repost_item(buffer.session, item_uri)
+                output.speak(result["message"], True)
+            wx.CallAfter(asyncio.create_task, _repost())
+
 
     def add_to_favourites(self, *args, **kwargs):
         buffer = self.get_current_buffer()
-        if hasattr(buffer, "add_to_favorites"):
+        if hasattr(buffer, "add_to_favorites"): # Generic buffer method
             return buffer.add_to_favorites()
+        elif buffer.session and buffer.session.KIND == "atprotosocial":
+            item_uri = buffer.get_selected_item_id()
+            if not item_uri:
+                output.speak(_("No item selected to like."), True)
+                return
+            social_handler = self.get_handler(buffer.session.KIND)
+            async def _like():
+                result = await social_handler.like_item(buffer.session, item_uri)
+                output.speak(result["message"], True)
+                if result.get("status") == "success" and result.get("like_uri"):
+                    # Store the like URI if the buffer supports it, for unliking
+                    if hasattr(buffer, "store_item_viewer_state"):
+                        buffer.store_item_viewer_state(item_uri, "like_uri", result["like_uri"])
+            wx.CallAfter(asyncio.create_task, _like())
+
 
     def remove_from_favourites(self, *args, **kwargs):
         buffer = self.get_current_buffer()
-        if hasattr(buffer, "remove_from_favorites"):
+        if hasattr(buffer, "remove_from_favorites"): # Generic buffer method
             return buffer.remove_from_favorites()
+        elif buffer.session and buffer.session.KIND == "atprotosocial":
+            item_uri = buffer.get_selected_item_id() # URI of the post
+            if not item_uri:
+                output.speak(_("No item selected to unlike."), True)
+                return
+            
+            like_uri = None
+            if hasattr(buffer, "get_item_viewer_state"):
+                like_uri = buffer.get_item_viewer_state(item_uri, "like_uri")
+
+            if not like_uri:
+                output.speak(_("Could not find the original like record for this post. You might need to unlike it from the Bluesky app directly or refresh your timeline."), True)
+                # As a fallback, one could try to *find* the like record by listing likes for the post,
+                # but this is complex and slow for a quick action.
+                # For now, we rely on having the like_uri stored.
+                # Alternatively, some platforms allow unliking by post URI directly if the like exists.
+                # ATProto delete_like requires the like record URI.
+                logger.warning(f"Attempted to unlike post {item_uri} but its like_uri was not found in buffer's viewer_state.")
+                return
+
+            social_handler = self.get_handler(buffer.session.KIND)
+            async def _unlike():
+                result = await social_handler.unlike_item(buffer.session, like_uri) # Pass the like's own URI
+                output.speak(result["message"], True)
+                if result.get("status") == "success":
+                    if hasattr(buffer, "store_item_viewer_state"):
+                        buffer.store_item_viewer_state(item_uri, "like_uri", None) # Clear stored like URI
+            wx.CallAfter(asyncio.create_task, _unlike())
+
 
     def toggle_like(self, *args, **kwargs):
         buffer = self.get_current_buffer()
@@ -1008,20 +1084,141 @@ class Controller(object):
     def update_buffers(self):
         for i in self.buffers[:]:
             if i.session != None and i.session.is_logged == True:
+                # For ATProtoSocial, initial load is in session.start() or manual.
+                # Periodic updates would need a separate timer or manual refresh via update_buffer.
+                if i.session.KIND != "atprotosocial":
                     try:
-                    i.start_stream(mandatory=True)
+                        i.start_stream(mandatory=True) # This is likely for streaming connections or timed polling within buffer
                     except Exception as err:
                         log.exception("Error %s starting buffer %s on account %s, with args %r and kwargs %r." % (str(err), i.name, i.account, i.args, i.kwargs))
 
     def update_buffer(self, *args, **kwargs):
-        bf = self.get_current_buffer()
+        """Handles the 'Update buffer' menu command to fetch newest items."""
-        if not hasattr(bf, "start_stream"):
+        bf = self.get_current_buffer() # bf is the buffer panel instance
-            output.speak(_(u"Unable to update this buffer."))
+        if not bf or not hasattr(bf, "session") or not bf.session:
+            output.speak(_(u"No active session for this buffer."), True)
             return
-        output.speak(_(u"Updating buffer..."))
+
-        n = bf.start_stream(mandatory=True, avoid_autoreading=True)
+        output.speak(_(u"Updating buffer..."), True)
-        if n != None:
+        session = bf.session
-            output.speak(_(u"{0} items retrieved").format(n,))
+        
+        async def do_update():
+            new_ids = []
+            try:
+                if session.KIND == "atprotosocial":
+                    if bf.name == f"{session.label} Home": # Assuming buffer name indicates type
+                        # ATProtoSocial home timeline uses new_only=True for fetching newest
+                        new_ids, _ = await session.fetch_home_timeline(limit=config.app["app-settings"].get("items_per_request", 20), new_only=True)
+                    elif bf.name == f"{session.label} Notifications":
+                         _, _ = await session.fetch_notifications(limit=config.app["app-settings"].get("items_per_request", 20)) # new_only implied by unread
+                         # fetch_notifications itself handles UI updates via send_notification_to_channel
+                         # so new_ids might not be directly applicable here unless fetch_notifications returns them
+                         # For simplicity, we'll assume it updates the buffer internally or via pubsub.
+                         # The count 'n' below might not be accurate for notifications this way.
+                    # Add other ATProtoSocial buffer types here (e.g., user timeline, mentions)
+                    # elif bf.name.startswith(f"{session.label} User Feed"): # Example for a user feed buffer
+                    #     target_user_did = getattr(bf, 'target_user_did', None) # Panel needs to store this
+                    #     if target_user_did:
+                    #         new_ids, _ = await session.fetch_user_timeline(user_did=target_user_did, limit=config.app["app-settings"].get("items_per_request", 20), new_only=True)
+                    else:
+                        # Fallback to original buffer's start_stream if it's not an ATProtoSocial specific buffer we handle here
+                        if hasattr(bf, "start_stream"):
+                            count = bf.start_stream(mandatory=True, avoid_autoreading=True)
+                            if count is not None: new_ids = [str(x) for x in range(count)] # Dummy IDs for count
+                        else:
+                            output.speak(_(u"This buffer type cannot be updated in this way."), True)
+                            return
+                else: # For other session types (e.g. Mastodon)
+                    if hasattr(bf, "start_stream"):
+                        count = bf.start_stream(mandatory=True, avoid_autoreading=True)
+                        if count is not None: new_ids = [str(x) for x in range(count)] # Dummy IDs for count
+                    else:
+                        output.speak(_(u"Unable to update this buffer."), True)
+                        return
+                
+                # Generic feedback based on new_ids for timelines
+                if bf.name == f"{session.label} Home" or bf.name.startswith(f"{session.label} User Feed"): # Refine condition
+                    output.speak(_("{0} items retrieved").format(len(new_ids)), True)
+                elif bf.name == f"{session.label} Notifications":
+                     output.speak(_("Notifications updated."), True) # Or specific count if fetch_notifications returns it
+
+            except NotificationError as e:
+                output.speak(str(e), True)
+            except Exception as e_general:
+                logger.error(f"Error updating buffer {bf.name}: {e_general}", exc_info=True)
+                output.speak(_("An error occurred while updating the buffer."), True)
+
+        wx.CallAfter(asyncio.create_task, do_update())
+
+
+    def get_more_items(self, *args, **kwargs):
+        """Handles 'Load previous items' menu command."""
+        bf = self.get_current_buffer() # bf is the buffer panel instance
+        if not bf or not hasattr(bf, "session") or not bf.session:
+            output.speak(_(u"No active session for this buffer."), True)
+            return
+
+        session = bf.session
+        # The buffer panel (bf) needs to store its own cursor for pagination of older items
+        # e.g., bf.pagination_cursor or bf.older_items_cursor
+        # This cursor should be set by the result of previous fetch_..._timeline(new_only=False) calls.
+        
+        # For ATProtoSocial, session methods like fetch_home_timeline store their own cursor (e.g., session.home_timeline_cursor)
+        # The panel might need to get this initial cursor or manage its own if it's for a dynamic list (user feed).
+        
+        current_cursor = None
+        if session.KIND == "atprotosocial":
+            if bf.name == f"{session.label} Home":
+                current_cursor = session.home_timeline_cursor
+            # elif bf.name.startswith(f"{session.label} User Feed"):
+            #     current_cursor = getattr(bf, 'pagination_cursor', None) # Panel specific cursor
+            # elif bf.name == f"{session.label} Notifications":
+            #     current_cursor = getattr(bf, 'pagination_cursor', None) # Panel specific cursor for notifications
+            else: # Fallback or other buffer types
+                if hasattr(bf, "get_more_items"): # Try generic buffer method
+                    return bf.get_more_items()
+                else:
+                    output.speak(_(u"This buffer does not support loading more items in this way."), True)
+                    return
+        else: # For other session types
+            if hasattr(bf, "get_more_items"):
+                return bf.get_more_items()
+            else:
+                output.speak(_(u"This buffer does not support loading more items."), True)
+                return
+
+        output.speak(_(u"Loading more items..."), True)
+        
+        async def do_load_more():
+            loaded_ids = []
+            try:
+                if session.KIND == "atprotosocial":
+                    if bf.name == f"{session.label} Home":
+                        loaded_ids, _ = await session.fetch_home_timeline(cursor=current_cursor, limit=config.app["app-settings"].get("items_per_request", 20), new_only=False)
+                    # elif bf.name.startswith(f"{session.label} User Feed"):
+                    #     target_user_did = getattr(bf, 'target_user_did', None)
+                    #     if target_user_did:
+                    #         loaded_ids, new_cursor = await session.fetch_user_timeline(user_did=target_user_did, cursor=current_cursor, limit=config.app["app-settings"].get("items_per_request", 20), new_only=False)
+                    #         if hasattr(bf, "pagination_cursor"): bf.pagination_cursor = new_cursor
+                    # elif bf.name == f"{session.label} Notifications":
+                    #     new_cursor = await session.fetch_notifications(cursor=current_cursor, limit=config.app["app-settings"].get("items_per_request", 20))
+                    #     if hasattr(bf, "pagination_cursor"): bf.pagination_cursor = new_cursor
+                        # fetch_notifications updates UI itself. loaded_ids might not be directly applicable.
+                    # For now, only home timeline "load more" is fully wired via session cursor.
+                
+                if loaded_ids: # Check if any IDs were actually loaded
+                    output.speak(_("{0} more items retrieved").format(len(loaded_ids)), True)
+                else:
+                    output.speak(_("No more items found or loaded."), True)
+
+            except NotificationError as e:
+                output.speak(str(e), True)
+            except Exception as e_general:
+                logger.error(f"Error loading more items for buffer {bf.name}: {e_general}", exc_info=True)
+                output.speak(_("An error occurred while loading more items."), True)
+        
+        wx.CallAfter(asyncio.create_task, do_load_more())
+
 
     def buffer_title_changed(self, buffer):
         if buffer.name.endswith("-timeline"):
@@ -1114,21 +1311,63 @@ class Controller(object):
     def user_details(self, *args):
         """Displays a user's profile."""
         log.debug("Showing user profile...")
-        buffer = self.get_best_buffer()
+        buffer = self.get_current_buffer() # Use current buffer to get context if item is selected
+        if not buffer or not buffer.session:
+            buffer = self.get_best_buffer() # Fallback if current buffer has no session
+        
+        if not buffer or not buffer.session:
+            output.speak(_("No active session to view user details."), True)
+            return
+
         handler = self.get_handler(type=buffer.session.type)
         if handler and hasattr(handler, 'user_details'):
+            # user_details handler in Mastodon takes the buffer directly, which then extracts item/user
+            # For ATProtoSocial, we might need to pass the user DID or handle if available from selected item
+            # This part assumes the buffer has a way to provide the target user's identifier
             handler.user_details(buffer) 
+        else:
+            output.speak(_("This session type does not support viewing user details in this way."), True)
 
-    def openPostTimeline(self, *args, user=None):
+
+    def openPostTimeline(self, *args, user=None): # "user" here is often the user object from selected item
         """Opens selected user's posts timeline
         Parameters:
         args: Other argument. Useful when binding to widgets.
-        user: if specified, open this user timeline. It is currently mandatory, but could be optional when user selection is implemented in handler
+        user: if specified, open this user timeline. It is currently mandatory, but could be optional when user selection is implemented in handler. 
+              `user` is typically a dict or object with user info from the selected post/item.
         """
-        buffer = self.get_best_buffer()
+        current_buffer = self.get_current_buffer() # Get context from current buffer first
-        handler = self.get_handler(type=buffer.session.type)
+        if not current_buffer or not current_buffer.session:
-        if handler and hasattr(handler, 'openPostTimeline'):
+            current_buffer = self.get_best_buffer()
-            handler.openPostTimeline(self, buffer, user)
+
+        if not current_buffer or not current_buffer.session:
+            output.speak(_("No active session available."), True)
+            return
+
+        session_to_use = current_buffer.session
+        handler = self.get_handler(type=session_to_use.type)
+
+        if handler and hasattr(handler, 'open_user_timeline'): # Changed to a more generic name
+            # The handler's open_user_timeline should extract user_id (DID for ATProto)
+            # from the 'user' object or prompt if 'user' is None.
+            # 'user' object is often derived from the selected item in the current buffer.
+            if user is None and hasattr(current_buffer, 'get_selected_item_author_details'):
+                 # Try to get author from selected item in current buffer if 'user' not passed directly
+                 author_details = current_buffer.get_selected_item_author_details()
+                 if author_details:
+                     user = author_details # This would be a dict/object the handler can parse
+            
+            # Call the handler method. It will be responsible for creating the new buffer.
+            # The handler's open_user_timeline will need access to 'self' (mainController) to call add_buffer.
+            async def _open_timeline():
+                await handler.open_user_timeline(main_controller=self, session=session_to_use, user_payload=user)
+            wx.CallAfter(asyncio.create_task, _open_timeline())
+            
+        elif handler and hasattr(handler, 'openPostTimeline'): # Fallback for older handler structure
+            handler.openPostTimeline(self, current_buffer, user)
+        else:
+            output.speak(_("This session type does not support opening user timelines directly."), True)
+
 
     def openFollowersTimeline(self, *args, user=None):
         """Opens selected user's followers timeline
@@ -1136,10 +1375,30 @@ class Controller(object):
         args: Other argument. Useful when binding to widgets.
         user: if specified, open this user timeline. It is currently mandatory, but could be optional when user selection is implemented in handler
         """
-        buffer = self.get_best_buffer()
+        current_buffer = self.get_current_buffer()
-        handler = self.get_handler(type=buffer.session.type)
+        if not current_buffer or not current_buffer.session:
-        if handler and hasattr(handler, 'openFollowersTimeline'):
+            current_buffer = self.get_best_buffer()
-            handler.openFollowersTimeline(self, buffer, user)
+        
+        if not current_buffer or not current_buffer.session:
+            output.speak(_("No active session available."), True)
+            return
+
+        session_to_use = current_buffer.session
+        handler = self.get_handler(type=session_to_use.type)
+
+        if user is None and hasattr(current_buffer, 'get_selected_item_author_details'):
+            author_details = current_buffer.get_selected_item_author_details()
+            if author_details: user = author_details
+
+        if handler and hasattr(handler, 'open_followers_timeline'):
+            async def _open_followers():
+                await handler.open_followers_timeline(main_controller=self, session=session_to_use, user_payload=user)
+            wx.CallAfter(asyncio.create_task, _open_followers())
+        elif handler and hasattr(handler, 'openFollowersTimeline'): # Fallback
+            handler.openFollowersTimeline(self, current_buffer, user)
+        else:
+            output.speak(_("This session type does not support opening followers list."), True)
+
 
     def openFollowingTimeline(self, *args, user=None):
         """Opens selected user's  following timeline
@@ -1147,12 +1406,32 @@ class Controller(object):
         args: Other argument. Useful when binding to widgets.
         user: if specified, open this user timeline. It is currently mandatory, but could be optional when user selection is implemented in handler
         """
-        buffer = self.get_best_buffer()
+        current_buffer = self.get_current_buffer()
-        handler = self.get_handler(type=buffer.session.type)
+        if not current_buffer or not current_buffer.session:
-        if handler and hasattr(handler, 'openFollowingTimeline'):
+            current_buffer = self.get_best_buffer()
-            handler.openFollowingTimeline(self, buffer, user)
 
-    def community_timeline(self, *args, user=None):
+        if not current_buffer or not current_buffer.session:
+            output.speak(_("No active session available."), True)
+            return
+            
+        session_to_use = current_buffer.session
+        handler = self.get_handler(type=session_to_use.type)
+
+        if user is None and hasattr(current_buffer, 'get_selected_item_author_details'):
+            author_details = current_buffer.get_selected_item_author_details()
+            if author_details: user = author_details
+            
+        if handler and hasattr(handler, 'open_following_timeline'):
+            async def _open_following():
+                await handler.open_following_timeline(main_controller=self, session=session_to_use, user_payload=user)
+            wx.CallAfter(asyncio.create_task, _open_following())
+        elif handler and hasattr(handler, 'openFollowingTimeline'): # Fallback
+            handler.openFollowingTimeline(self, current_buffer, user)
+        else:
+            output.speak(_("This session type does not support opening following list."), True)
+
+
+    def community_timeline(self, *args, user=None): # user param seems unused here based on mastodon impl
         buffer = self.get_best_buffer()
         handler = self.get_handler(type=buffer.session.type)
         if handler and hasattr(handler, 'community_timeline'):

src/sessionmanager/sessionManager.py

@@ -11,10 +11,12 @@ import paths
 import config_utils
 import config
 import application
+import asyncio # For async event handling
 from pubsub import pub
 from controller import settings
 from sessions.mastodon import session as MastodonSession
 from sessions.gotosocial import session as GotosocialSession
+from sessions.atprotosocial import session as ATProtoSocialSession # Import ATProtoSocial session
 from . import manager
 from . import wxUI as view
 
@@ -35,7 +37,8 @@ class sessionManagerController(object):
         # Initialize the manager, responsible for storing session objects.
         manager.setup()
         self.view = view.sessionManagerWindow()
-        pub.subscribe(self.manage_new_account, "sessionmanager.new_account")
+        # Using CallAfter to handle async method from pubsub
+        pub.subscribe(lambda type: wx.CallAfter(asyncio.create_task, self.manage_new_account(type)), "sessionmanager.new_account")
         pub.subscribe(self.remove_account, "sessionmanager.remove_account")
         if self.started == False:
             pub.subscribe(self.configuration, "sessionmanager.configuration")
@@ -67,12 +70,28 @@ class sessionManagerController(object):
                         continue
                 if config_test.get("mastodon") != None:
                     name = _("{account_name}@{instance} (Mastodon)").format(account_name=config_test["mastodon"]["user_name"], instance=config_test["mastodon"]["instance"].replace("https://", ""))
-                    if config_test["mastodon"]["instance"] != "" and config_test["mastodon"]["access_token"] != "":
+                    if config_test["mastodon"]["instance"] != "" and config_test["mastodon"]["access_token"] != "": # Basic validation
                         sessionsList.append(name)
                         self.sessions.append(dict(type=config_test["mastodon"].get("type", "mastodon"), id=i))
-                else:
+                elif config_test.get("atprotosocial") != None: # Check for ATProtoSocial config
+                    handle = config_test["atprotosocial"].get("handle")
+                    did = config_test["atprotosocial"].get("did") # DID confirms it was authorized
+                    if handle and did:
+                        name = _("{handle} (Bluesky)").format(handle=handle)
+                        sessionsList.append(name)
+                        self.sessions.append(dict(type="atprotosocial", id=i))
+                    else: # Incomplete config, might be an old attempt or error
+                        log.warning(f"Incomplete ATProtoSocial session config found for {i}, skipping.")
+                        # Optionally delete malformed config here too
                         try:
-                        log.debug("Deleting session %s" % (i,))
+                            log.debug("Deleting incomplete ATProtoSocial session %s" % (i,))
+                            shutil.rmtree(os.path.join(paths.config_path(), i))
+                        except Exception as e:
+                            log.exception(f"Error deleting incomplete ATProtoSocial session {i}: {e}")
+                        continue
+                else: # Unknown or other session type not explicitly handled here for display
+                    try:
+                        log.debug("Deleting session %s with unknown type" % (i,))
                         shutil.rmtree(os.path.join(paths.config_path(), i))
                     except:
                         output.speak("An exception was raised while attempting to clean malformed session data. See the error log for details. If this message persists, contact the developers.",True)
@@ -97,30 +116,92 @@ class sessionManagerController(object):
                 s = MastodonSession.Session(i.get("id"))
             elif i.get("type") == "gotosocial":
                 s = GotosocialSession.Session(i.get("id"))
-            s.get_configuration()
+            elif i.get("type") == "atprotosocial": # Handle ATProtoSocial session type
-            if i.get("id") not in config.app["sessions"]["ignored_sessions"]:
+                s = ATProtoSocialSession.Session(i.get("id"))
-                try:
+            else:
-                    s.login()
+                log.warning(f"Unknown session type '{i.get('type')}' for ID {i.get('id')}. Skipping.")
-                except Exception as e:
-                    log.exception("Exception during login on a TWBlue session.")
                 continue
-            sessions.sessions[i.get("id")] = s
+                
-            self.new_sessions[i.get("id")] = s
+            s.get_configuration() # Assumes get_configuration() exists and is useful for all session types
+                                  # For ATProtoSocial, this loads from its specific config file.
+            
+            # Login is now primarily handled by session.start() via mainController,
+            # which calls _ensure_dependencies_ready().
+            # Explicit s.login() here might be redundant or premature if full app context isn't ready.
+            # We'll rely on the mainController to call session.start() which handles login.
+            # if i.get("id") not in config.app["sessions"]["ignored_sessions"]:
+            #     try:
+            #         # For ATProtoSocial, login is async and handled by session.start()
+            #         # if not s.is_ready(): # Only attempt login if not already ready
+            #         #    log.info(f"Session {s.uid} ({s.kind}) not ready, login will be attempted by start().")
+            #         pass
+            #     except Exception as e:
+            #         log.exception(f"Exception during pre-emptive login check for session {s.uid} ({s.kind}).")
+            #         continue
+            sessions.sessions[i.get("id")] = s # Add to global session store
+            self.new_sessions[i.get("id")] = s # Track as a new session for this manager instance
 #  self.view.destroy()
 
     def show_auth_error(self):
-        error = view.auth_error()
+        error = view.auth_error() # This seems to be a generic auth error display
 
-    def manage_new_account(self, type):
+    async def manage_new_account(self, type): # Made async
         # Generic settings for all account types.
-        location = (str(time.time())[-6:])
+        location = (str(time.time())[-6:]) # Unique ID for the session config directory
         log.debug("Creating %s session in the %s path" % (type, location))
+        
+        s: sessions.base.baseSession | None = None # Type hint for session object
+        
         if type == "mastodon":
             s = MastodonSession.Session(location)
-        result = s.authorise()
+        elif type == "atprotosocial":
+            s = ATProtoSocialSession.Session(location)
+        # Add other session types here if needed (e.g., gotosocial)
+        # elif type == "gotosocial":
+        # s = GotosocialSession.Session(location)
+            
+        if not s:
+            log.error(f"Unsupported session type for creation: {type}")
+            self.view.show_unauthorised_error() # Or a more generic "cannot create" error
+            return
+
+        try:
+            result = await s.authorise() # Call the (now potentially async) authorise method
             if result == True:
-            self.sessions.append(dict(id=location, type=s.settings["mastodon"].get("type")))
+                # Session config (handle, did for atproto) should be saved by authorise/login.
-            self.view.add_new_session_to_list()
+                # Here we just update the session manager's internal list and UI.
+                session_type_for_dict = type # Store the actual type string
+                if hasattr(s, 'settings') and s.settings and s.settings.get(type) and s.settings[type].get("type"):
+                    # Mastodon might have a more specific type in its settings (e.g. gotosocial)
+                     session_type_for_dict = s.settings[type].get("type")
+
+                self.sessions.append(dict(id=location, type=session_type_for_dict))
+                self.view.add_new_session_to_list() # This should update the UI list
+                # The session object 's' itself isn't stored in self.new_sessions until do_ok if app is restarting
+                # But for immediate use if not restarting, it might need to be added to sessions.sessions
+                sessions.sessions[location] = s # Make it globally available immediately
+                self.new_sessions[location] = s
+
+
+            else: # Authorise returned False or None
+                self.view.show_unauthorised_error()
+                # Clean up the directory if authorization failed and nothing was saved
+                if os.path.exists(os.path.join(paths.config_path(), location)):
+                    try:
+                        shutil.rmtree(os.path.join(paths.config_path(), location))
+                        log.info(f"Cleaned up directory for failed auth: {location}")
+                    except Exception as e_rm:
+                        log.error(f"Error cleaning up directory {location} after failed auth: {e_rm}")
+        except Exception as e:
+            log.error(f"Error during new account authorization for type {type}: {e}", exc_info=True)
+            self.view.show_unauthorised_error() # Show generic error
+            # Clean up
+            if os.path.exists(os.path.join(paths.config_path(), location)):
+                try:
+                    shutil.rmtree(os.path.join(paths.config_path(), location))
+                except Exception as e_rm:
+                    log.error(f"Error cleaning up directory {location} after exception: {e_rm}")
+
 
     def remove_account(self, index):
         selected_account = self.sessions[index]

src/sessionmanager/wxUI.py

@@ -53,6 +53,10 @@ class sessionManagerWindow(wx.Dialog):
         menu = wx.Menu()
         mastodon = menu.Append(wx.ID_ANY, _("Mastodon"))
         menu.Bind(wx.EVT_MENU, self.on_new_mastodon_account, mastodon)
+        
+        atprotosocial = menu.Append(wx.ID_ANY, _("ATProtoSocial (Bluesky)"))
+        menu.Bind(wx.EVT_MENU, self.on_new_atprotosocial_account, atprotosocial)
+        
         self.PopupMenu(menu, self.new.GetPosition())
 
     def on_new_mastodon_account(self, *args, **kwargs):
@@ -62,6 +66,13 @@ class sessionManagerWindow(wx.Dialog):
         if response == wx.ID_YES:
             pub.sendMessage("sessionmanager.new_account", type="mastodon")
 
+    def on_new_atprotosocial_account(self, *args, **kwargs):
+        dlg = wx.MessageDialog(self, _("You will be prompted for your ATProtoSocial (Bluesky) data (user handle and App Password) to authorize TWBlue. Would you like to authorize your account now?"), _(u"ATProtoSocial Authorization"), wx.YES_NO)
+        response = dlg.ShowModal()
+        dlg.Destroy()
+        if response == wx.ID_YES:
+            pub.sendMessage("sessionmanager.new_account", type="atprotosocial")
+
     def add_new_session_to_list(self):
         total = self.list.get_count()
         name = _(u"Authorized account %d") % (total+1)

src/sessions/atprotosocial/__init__.py

@@ -0,0 +1,3 @@
+from .session import Session
+
+__all__ = ["Session"]

src/sessions/atprotosocial/compose.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+fromapprove.translation import translate as _
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+
+logger = logging.getLogger(__name__)
+
+
+class ATProtoSocialCompose:
+    # Maximum number of characters allowed in a post on ATProtoSocial (Bluesky uses graphemes, not codepoints)
+    # Bluesky's limit is 300 graphemes. This might need adjustment based on how Python handles graphemes.
+    MAX_CHARS = 300 # Defined by app.bsky.feed.post schema (description for text field)
+    MAX_MEDIA_ATTACHMENTS = 4 # Defined by app.bsky.embed.images schema (maxItems for images array)
+    MAX_LANGUAGES = 3 # Defined by app.bsky.feed.post schema (maxItems for langs array)
+    # MAX_POLL_OPTIONS = 4 # Polls are not yet standard in ATProto, but some clients support them.
+    # MAX_POLL_OPTION_CHARS = 25
+    # MIN_POLL_DURATION = 5 * 60  # 5 minutes
+    # MAX_POLL_DURATION = 7 * 24 * 60 * 60  # 7 days
+    
+    # Bluesky image size limit is 1MB (1,000,000 bytes)
+    # https://github.com/bluesky-social/social-app/blob/main/src/lib/constants.ts#L28
+    MAX_IMAGE_SIZE_BYTES = 1_000_000 
+
+
+    def __init__(self, session: ATProtoSocialSession) -> None:
+        self.session = session
+        self.supported_media_types: list[str] = ["image/jpeg", "image/png"]
+        self.max_image_size_bytes: int = self.MAX_IMAGE_SIZE_BYTES
+
+
+    def get_panel_configuration(self) -> dict[str, Any]:
+        """Returns configuration for the compose panel specific to ATProtoSocial."""
+        return {
+            "max_chars": self.MAX_CHARS,
+            "max_media_attachments": self.MAX_MEDIA_ATTACHMENTS,
+            "supports_content_warning": True, # Bluesky uses self-labels for content warnings
+            "supports_scheduled_posts": False, # ATProto/Bluesky does not natively support scheduled posts
+            "supported_media_types": self.supported_media_types,
+            "max_media_size_bytes": self.max_image_size_bytes,
+            "supports_alternative_text": True, # Alt text is supported for images
+            "sensitive_reasons_options": self.session.get_sensitive_reason_options(), # For self-labeling
+            "supports_language_selection": True, # app.bsky.feed.post supports 'langs' field
+            "max_languages": self.MAX_LANGUAGES,
+            "supports_quoting": True, # Bluesky supports quoting via app.bsky.embed.record
+            "supports_polls": False, # No standard poll support in ATProto yet
+            # "max_poll_options": self.MAX_POLL_OPTIONS,
+            # "max_poll_option_chars": self.MAX_POLL_OPTION_CHARS,
+            # "min_poll_duration": self.MIN_POLL_DURATION,
+            # "max_poll_duration": self.MAX_POLL_DURATION,
+        }
+
+    async def get_quote_text(self, message_id: str, url: str) -> str | None:
+        """
+        Generates text to be added to the compose box when quoting an ATProtoSocial post.
+        For Bluesky, the actual quote is an embed. This text is typically appended by the user.
+        `message_id` here is the AT-URI of the post to be quoted.
+        `url` is the web URL of the post.
+        """
+        # The actual embedding of a quote is handled in session.send_message by passing quote_uri.
+        # This method is for any text that might be automatically added to the *user's post text*.
+        # Often, users just add the link manually, or clients might add "QT: [link]".
+        # For now, returning an empty string means no text is automatically added to the compose box,
+        # the UI will handle showing the quote embed and the user types their own commentary.
+        # Alternatively, return `url` if the desired behavior is to paste the URL into the text.
+        
+        # Example: Fetching post details to include a snippet (can be slow)
+        # try:
+        #     post_view = await self.session.util.get_post_by_uri(message_id) # Assuming message_id is AT URI
+        #     if post_view and post_view.author and post_view.record:
+        #         author_handle = post_view.author.handle
+        #         text_snippet = str(post_view.record.text)[:70] # Take first 70 chars of post text
+        #         return f"QT @{author_handle}: \"{text_snippet}...\"\n{url}\n"
+        # except Exception as e:
+        #     logger.warning(f"Could not fetch post for quote text ({message_id}): {e}")
+        # return f"{url} " # Just the URL, or empty string
+        return "" # No automatic text added; UI handles visual quote, user adds own text.
+
+
+    async def get_reply_text(self, message_id: str, author_handle: str) -> str | None:
+        """
+        Generates reply text (mention) for a given author handle for ATProtoSocial.
+        """
+        # TODO: Confirm if any specific prefix is needed beyond the mention.
+        # Bluesky handles mentions with "@handle.example.com"
+        if not author_handle.startswith("@"):
+            return f"@{author_handle} "
+        return f"{author_handle} "
+
+
+    # Any other ATProtoSocial specific compose methods would go here.
+    # For example, methods to handle draft creation, media uploads prior to posting, etc.
+    # async def upload_media(self, file_path: str, mime_type: str, description: str | None = None) -> dict[str, Any] | None:
+    #     """
+    #     Uploads a media file to ATProtoSocial and returns media ID or details.
+    #     This would use the atproto client's blob upload.
+    #     """
+    #     # try:
+    #     #     # client = self.session.util.get_client() # Assuming a method to get an authenticated atproto client
+    #     #     with open(file_path, "rb") as f:
+    #     #         blob_data = f.read()
+    #     #     # response = await client.com.atproto.repo.upload_blob(blob_data, mime_type=mime_type)
+    #     #     # return {"id": response.blob.ref, "url": response.blob.cid, "description": description} # Example structure
+    #     #     logger.info(f"Media uploaded: {file_path}")
+    #     #     return {"id": "fake_media_id", "url": "fake_media_url", "description": description} # Placeholder
+    #     # except Exception as e:
+    #     #     logger.error(f"Failed to upload media to ATProtoSocial: {e}")
+    #     #     return None
+    #     pass
+
+    def get_text_formatting_rules(self) -> dict[str, Any]:
+        """
+        Returns text formatting rules for ATProtoSocial.
+        Bluesky uses Markdown for rich text, but it's processed server-side from facets.
+        Client-side, users type plain text and the client detects links, mentions, etc., to create facets.
+        """
+        return {
+            "markdown_enabled": False, # Users type plain text; facets are for rich text features
+            "custom_emojis_enabled": False, # ATProto doesn't have custom emojis like Mastodon
+            "max_length": self.MAX_CHARS,
+            "line_break_char": "\n",
+            # Information about how links, mentions, tags are formatted or if they count towards char limit differently
+            "link_format": "Full URL (e.g., https://example.com)", # Links are typically full URLs
+            "mention_format": "@handle.bsky.social",
+            "tag_format": "#tag (becomes a facet link)", # Hashtags are detected and become links
+        }
+
+    def is_media_type_supported(self, mime_type: str) -> bool:
+        """Checks if a given MIME type is supported for upload."""
+        # TODO: Use actual supported types from `self.supported_media_types`
+        return mime_type.lower() in self.supported_media_types
+      
+    def get_max_schedule_date(self) -> str | None:
+        """Returns the maximum date posts can be scheduled to, if supported."""
+        # ATProtoSocial does not natively support scheduled posts.
+        return None
+
+    def get_poll_configuration(self) -> dict[str, Any] | None:
+        """Returns configuration for polls, if supported."""
+        # Polls are not a standard part of ATProto yet.
+        # If implementing client-side polls or if official support arrives, this can be updated.
+        # return {
+        #     "max_options": self.MAX_POLL_OPTIONS,
+        #     "max_option_chars": self.MAX_POLL_OPTION_CHARS,
+        #     "min_duration_seconds": self.MIN_POLL_DURATION,
+        #     "max_duration_seconds": self.MAX_POLL_DURATION,
+        #     "default_duration_seconds": 24 * 60 * 60,  # 1 day
+        # }
+        return None

src/sessions/atprotosocial/streaming.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any, Callable, Coroutine
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+
+logger = logging.getLogger(__name__)
+
+# ATProtoSocial (Bluesky) uses a Firehose model for streaming.
+# This typically involves connecting to a WebSocket endpoint and receiving events.
+# The atproto SDK provides tools for this.
+
+
+class ATProtoSocialStreaming:
+    def __init__(self, session: ATProtoSocialSession, stream_type: str, params: dict[str, Any] | None = None) -> None:
+        self.session = session
+        self.stream_type = stream_type  # e.g., 'user', 'public', 'hashtag' - will need mapping to Firehose concepts
+        self.params = params or {}
+        self._handler: Callable[[dict[str, Any]], Coroutine[Any, Any, None]] | None = None
+        self._connection_task: asyncio.Task[None] | None = None
+        self._should_stop = False
+        # self._client = None # This would be an instance of atproto.firehose.FirehoseSubscribeReposClient or similar
+
+        # TODO: Map stream_type and params to ATProto Firehose subscription needs.
+        # For example, 'user' might mean subscribing to mentions, replies, follows for the logged-in user.
+        # This would likely involve filtering the general repo firehose for relevant events,
+        # or using a more specific subscription if available for user-level events.
+
+    async def _connect(self) -> None:
+        """Internal method to connect to the ATProtoSocial Firehose."""
+        # from atproto import AsyncClient
+        # from atproto.firehose import FirehoseSubscribeReposClient, parse_subscribe_repos_message
+        # from atproto.xrpc_client.models import get_or_create, ids, models
+
+        logger.info(f"ATProtoSocial streaming: Connecting to Firehose for user {self.session.user_id}, stream type {self.stream_type}")
+        self._should_stop = False
+
+        try:
+            # TODO: Replace with actual atproto SDK usage
+            # client = self.session.util.get_client() # Get authenticated client from session utils
+            # if not client or not client.me: # Check if client is authenticated
+            #    logger.error("ATProtoSocial client not authenticated. Cannot start Firehose.")
+            #    return
+
+            # self._firehose_client = FirehoseSubscribeReposClient(params=None, base_uri=self.session.api_base_url) # Adjust base_uri if needed
+
+            # async def on_message_handler(message: models.ComAtprotoSyncSubscribeRepos.Message) -> None:
+            #     if self._should_stop:
+            #         await self._firehose_client.stop() # Ensure client stops if flag is set
+            #         return
+
+            #     # This is a simplified example. Real implementation needs to:
+            #     # 1. Determine the type of message (commit, handle, info, migrate, tombstone)
+            #     # 2. For commits, unpack operations to find posts, likes, reposts, follows, etc.
+            #     # 3. Filter these events to be relevant to the user (e.g., mentions, replies to user, new posts from followed users)
+            #     # 4. Format the data into a structure that self._handle_event expects.
+            #     # This filtering can be complex.
+
+            #     # Example: if it's a commit and contains a new post that mentions the user
+            #     # if isinstance(message, models.ComAtprotoSyncSubscribeRepos.Commit):
+            #     #     # This part is highly complex due to CAR CIBOR decoding
+            #     #     # Operations need to be extracted from the commit block
+            #     #     # For each op, check if it's a create, and if the record is a post
+            #     #     # Then, check if the post's text or facets mention the current user.
+            #     #     # This is a placeholder for that logic.
+            #     #     logger.debug(f"Firehose commit from {message.repo} at {message.time}")
+            #     #     # Example of processing ops (pseudo-code, actual decoding is more involved):
+            #     #     # ops = message.ops
+            #     #     # for op in ops:
+            #     #     #   if op.action == 'create' and op.path.endswith('/app.bsky.feed.post/...'):
+            #     #     #       record_data = ... # decode op.cid from message.blocks
+            #     #     #       if self.session.util.is_mention_of_me(record_data):
+            #     #     #            event_data = self.session.util.format_post_event(record_data)
+            #     #     #            await self._handle_event("mention", event_data)
+
+            #     # For now, we'll just log that a message was received
+            #     logger.debug(f"ATProtoSocial Firehose message received: {message.__class__.__name__}")
+
+
+            # await self._firehose_client.start(on_message_handler)
+            
+            # Placeholder loop to simulate receiving events
+            while not self._should_stop:
+                await asyncio.sleep(1)
+                # In a real implementation, this loop wouldn't exist; it'd be driven by the SDK's event handler.
+                # To simulate an event:
+                # if self._handler:
+                #    mock_event = {"type": "placeholder_event", "data": {"text": "Hello from mock stream"}}
+                #    await self._handler(mock_event) # Call the registered handler
+
+            logger.info(f"ATProtoSocial streaming: Placeholder loop for {self.session.user_id} stopped.")
+
+
+        except asyncio.CancelledError:
+            logger.info(f"ATProtoSocial streaming task for user {self.session.user_id} was cancelled.")
+        except Exception as e:
+            logger.error(f"ATProtoSocial streaming error for user {self.session.user_id}: {e}", exc_info=True)
+            # Optional: implement retry logic here or in the start_streaming method
+            if not self._should_stop:
+                await asyncio.sleep(30) # Wait before trying to reconnect (if auto-reconnect is desired)
+                if not self._should_stop: # Check again before restarting
+                     self._connection_task = asyncio.create_task(self._connect())
+
+
+        finally:
+            # if self._firehose_client:
+            #    await self._firehose_client.stop()
+            logger.info(f"ATProtoSocial streaming connection closed for user {self.session.user_id}.")
+
+
+    async def _handle_event(self, event_type: str, data: dict[str, Any]) -> None:
+        """
+        Internal method to process an event from the stream and pass it to the session's handler.
+        """
+        if self._handler:
+            try:
+                # The data should be transformed into a common format expected by session.handle_streaming_event
+                # This is where ATProtoSocial-specific event data is mapped to Approve's internal event structure.
+                # For example, an ATProtoSocial 'mention' event needs to be structured similarly to
+                # how a Mastodon 'mention' event would be.
+                await self.session.handle_streaming_event(event_type, data)
+            except Exception as e:
+                logger.error(f"Error handling ATProtoSocial streaming event type {event_type}: {e}", exc_info=True)
+        else:
+            logger.warning(f"ATProtoSocial streaming: No handler registered for session {self.session.user_id}, event: {event_type}")
+
+
+    def start_streaming(self, handler: Callable[[dict[str, Any]], Coroutine[Any, Any, None]]) -> None:
+        """Starts the streaming connection."""
+        if self._connection_task and not self._connection_task.done():
+            logger.warning(f"ATProtoSocial streaming already active for user {self.session.user_id}.")
+            return
+
+        self._handler = handler # This handler is what session.py's handle_streaming_event calls
+        self._should_stop = False
+        logger.info(f"ATProtoSocial streaming: Starting for user {self.session.user_id}, type: {self.stream_type}")
+        self._connection_task = asyncio.create_task(self._connect())
+
+
+    async def stop_streaming(self) -> None:
+        """Stops the streaming connection."""
+        logger.info(f"ATProtoSocial streaming: Stopping for user {self.session.user_id}")
+        self._should_stop = True
+        # if self._firehose_client: # Assuming the SDK has a stop method
+        #     await self._firehose_client.stop()
+
+        if self._connection_task:
+            if not self._connection_task.done():
+                self._connection_task.cancel()
+            try:
+                await self._connection_task
+            except asyncio.CancelledError:
+                logger.info(f"ATProtoSocial streaming task successfully cancelled for {self.session.user_id}.")
+            self._connection_task = None
+        self._handler = None
+        logger.info(f"ATProtoSocial streaming stopped for user {self.session.user_id}.")
+
+    def is_alive(self) -> bool:
+        """Checks if the streaming connection is currently active."""
+        # return self._connection_task is not None and not self._connection_task.done() and self._firehose_client and self._firehose_client.is_connected
+        return self._connection_task is not None and not self._connection_task.done() # Simplified check
+
+    def get_stream_type(self) -> str:
+        return self.stream_type
+
+    def get_params(self) -> dict[str, Any]:
+        return self.params
+
+    # TODO: Add methods specific to ATProtoSocial streaming if necessary,
+    # e.g., methods to modify subscription details on the fly if the API supports it.
+    # For Bluesky Firehose, this might not be applicable as you usually connect and filter client-side.
+    # However, if there were different Firehose endpoints (e.g., one for public posts, one for user-specific events),
+    # this class might manage multiple connections or re-establish with new parameters.
+    
+    # Example of how events might be processed (highly simplified):
+    # This would be called by the on_message_handler in _connect
+    # async def _process_firehose_message(self, message: models.ComAtprotoSyncSubscribeRepos.Message):
+    #     if isinstance(message, models.ComAtprotoSyncSubscribeRepos.Commit):
+    #         # Decode CAR file in message.blocks to get ops
+    #         # For each op (create, update, delete of a record):
+    #         #   record = get_record_from_blocks(message.blocks, op.cid)
+    #         #   if op.path.startswith("app.bsky.feed.post"): # It's a post
+    #         #       # Check if it's a new post, a reply, a quote, etc.
+    #         #       # Check for mentions of the current user
+    #         #       # Example:
+    #         #       if self.session.util.is_mention_of_me(record):
+    #         #            formatted_event = self.session.util.format_post_as_notification(record, "mention")
+    #         #            await self._handle_event("mention", formatted_event)
+    #         #   elif op.path.startswith("app.bsky.graph.follow"):
+    #         #       # Check if it's a follow of the current user
+    #         #       if record.subject == self.session.util.get_my_did(): # Assuming get_my_did() exists
+    #         #            formatted_event = self.session.util.format_follow_as_notification(record)
+    #         #            await self._handle_event("follow", formatted_event)
+    #         #   # Handle likes (app.bsky.feed.like), reposts (app.bsky.feed.repost), etc.
+    #         pass
+    #     elif isinstance(message, models.ComAtprotoSyncSubscribeRepos.Handle):
+    #         # Handle DID to handle mapping updates if necessary
+    #         logger.debug(f"Handle update: {message.handle} now points to {message.did} at {message.time}")
+    #     elif isinstance(message, models.ComAtprotoSyncSubscribeRepos.Migrate):
+    #         logger.info(f"Repo migration: {message.did} migrating from {message.migrateTo} at {message.time}")
+    #     elif isinstance(message, models.ComAtprotoSyncSubscribeRepos.Tombstone):
+    #         logger.info(f"Repo tombstone: {message.did} at {message.time}")
+    #     elif isinstance(message, models.ComAtprotoSyncSubscribeRepos.Info):
+    #         logger.info(f"Firehose info: {message.name} - {message.message}")
+    #     else:
+    #         logger.debug(f"Unknown Firehose message type: {message.__class__.__name__}")

src/sessions/atprotosocial/templates.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+fromapprove.translation import translate as _
+
+if TYPE_CHECKING:
+    fromapprove.sessions.atprotosocial.session import Session as ATProtoSocialSession
+
+logger = logging.getLogger(__name__)
+
+
+class ATProtoSocialTemplates:
+    def __init__(self, session: ATProtoSocialSession) -> None:
+        self.session = session
+
+    def get_template_data(self, template_name: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
+        """
+        Returns data required for rendering a specific template for ATProtoSocial.
+        This method would populate template variables based on the template name and context.
+        """
+        base_data = {
+            "session_kind": self.session.kind,
+            "session_label": self.session.label,
+            "user_id": self.session.user_id,
+            # Add any other common data needed by ATProtoSocial templates
+        }
+        if context:
+            base_data.update(context)
+
+        # TODO: Implement specific data fetching for different ATProtoSocial templates
+        # Example:
+        # if template_name == "profile_summary.html":
+        #     # profile_info = await self.session.util.get_my_profile_info() # Assuming such a method exists
+        #     # base_data["profile"] = profile_info
+        #     base_data["profile"] = {"display_name": "User", "handle": "user.bsky.social"} # Placeholder
+        # elif template_name == "post_details.html":
+        #     # post_id = context.get("post_id")
+        #     # post_details = await self.session.util.get_post_by_id(post_id)
+        #     # base_data["post"] = post_details
+        #     base_data["post"] = {"text": "A sample post", "author_handle": "author.bsky.social"} # Placeholder
+
+        return base_data
+
+    def get_message_card_template(self) -> str:
+        """Returns the path to the message card template for ATProtoSocial."""
+        # This template would define how a single ATProtoSocial post (or other message type)
+        # is rendered in a list (e.g., in a timeline or search results).
+        # return "sessions/atprotosocial/cards/message.html" # Example path
+        return "sessions/generic/cards/message_generic.html" # Placeholder, use generic if no specific yet
+
+    def get_notification_template_map(self) -> dict[str, str]:
+        """
+        Returns a map of ATProtoSocial notification types to their respective template paths.
+        """
+        # TODO: Define templates for different ATProtoSocial notification types
+        # (e.g., mention, reply, new follower, like, repost).
+        # The keys should match the notification types used internally by Approve
+        # when processing ATProtoSocial events.
+        # Example:
+        # return {
+        #     "mention": "sessions/atprotosocial/notifications/mention.html",
+        #     "reply": "sessions/atprotosocial/notifications/reply.html",
+        #     "follow": "sessions/atprotosocial/notifications/follow.html",
+        #     "like": "sessions/atprotosocial/notifications/like.html", # Bluesky uses 'like'
+        #     "repost": "sessions/atprotosocial/notifications/repost.html", # Bluesky uses 'repost'
+        #     # ... other notification types
+        # }
+        # Using generic templates as placeholders:
+        return {
+            "mention": "sessions/generic/notifications/mention.html",
+            "reply": "sessions/generic/notifications/reply.html",
+            "follow": "sessions/generic/notifications/follow.html",
+            "like": "sessions/generic/notifications/favourite.html", # Map to favourite if generic expects that
+            "repost": "sessions/generic/notifications/reblog.html", # Map to reblog if generic expects that
+        }
+
+    def get_settings_template(self) -> str | None:
+        """Returns the path to the settings template for ATProtoSocial, if any."""
+        # This template would be used to render ATProtoSocial-specific settings in the UI.
+        # return "sessions/atprotosocial/settings.html"
+        return "sessions/generic/settings_auth_password.html" # If using simple handle/password auth
+
+    def get_user_action_templates(self) -> dict[str, str] | None:
+        """
+        Returns a map of user action identifiers to their template paths for ATProtoSocial.
+        User actions are typically buttons or forms displayed on a user's profile.
+        """
+        # TODO: Define templates for ATProtoSocial user actions
+        # Example:
+        # return {
+        #     "view_profile_on_bsky": "sessions/atprotosocial/actions/view_profile_button.html",
+        #     "send_direct_message": "sessions/atprotosocial/actions/send_dm_form.html", # If DMs are supported
+        # }
+        return None # Placeholder
+
+    def get_user_list_action_templates(self) -> dict[str, str] | None:
+        """
+        Returns a map of user list action identifiers to their template paths for ATProtoSocial.
+        These actions might appear on lists of users (e.g., followers, following).
+        """
+        # TODO: Define templates for ATProtoSocial user list actions
+        # Example:
+        # return {
+        #     "follow_all_visible": "sessions/atprotosocial/list_actions/follow_all_button.html",
+        # }
+        return None # Placeholder
+
+    # Add any other template-related helper methods specific to ATProtoSocial.
+    # For example, methods to get templates for specific types of content (images, polls)
+    # if they need special rendering.
+
+    def get_template_for_message_type(self, message_type: str) -> str | None:
+        """
+        Returns a specific template path for a given message type (e.g., post, reply, quote).
+        This can be useful if different types of messages need distinct rendering beyond the standard card.
+        """
+        # TODO: Define specific templates if ATProtoSocial messages have varied structures
+        # that require different display logic.
+        # if message_type == "quote_post":
+        #    return "sessions/atprotosocial/cards/quote_post.html"
+        return None # Default to standard message card if not specified