Skip to content

Piero Bosio Social Web Site Personale Logo Fediverso

Social Forum federato con il resto del mondo. Non contano le istanze, contano le persone
  1. Home
  2. Categories
  3. General Discussion
  4. nah, it really doesn't makes sense to live on two different open social platforms separately.

nah, it really doesn't makes sense to live on two different open social platforms separately.

General Discussion
7 3 1
Log in to reply

Feed RSS
nah, it really doesn't makes sense to live on two different open social platforms separately.

Gli ultimi otto messaggi ricevuti dalla Federazione
  • julian@activitypub.spaceundefined
    julian@activitypub.space

    josh@2tonwaffle.social :eyes:

    read more
  • mobileatom@flipboard.comundefined
    mobileatom@flipboard.com

    7.6.0 — Command, Sync & Go.

    https://activitypub.blog/2025/11/12/7-6-0-command-sync-go/?utm_source=flipboard&utm_medium=activitypub

    Posted into THE FEDIVERSE VS. CORPORATE SOCIAL MEDIA @the-fediverse-vs-corporate-social-media-mobileatom

    read more
  • josh@2tonwaffle.socialundefined
    josh@2tonwaffle.social

    Testing out sharing from a forum. I haven't installed the plugin yet, was just seeing how the manual way looks first.

    https://2tonwaffle.forum/t/test-topic-with-words/8?u=root

    read more
  • activitypub.blog@activitypub.blogundefined
    activitypub.blog@activitypub.blog

    This release puts speed and control right at your fingertips. Whether you’re jumping between settings, syncing followers, or handling quotes in real time, version 7.6.0 makes managing your Fediverse presence faster and more intuitive than ever.

    Wapuu, the yellow WordPress mascot, pilots a small spaceship shaped like the WordPress ‘W’ through a glowing Fediverse nebula. Light trails and floating ActivityPub icons surround the ship, symbolizing fast, effortless navigation through connected worlds.Navigate in a Flash

    Say hello to the quickest way to move around your ActivityPub settings.

    In preparation for WordPress 6.9, which brings the Command Palette (Cmd/Ctrl + K) to the entire wp-admin, the plugin now adds its own commands, giving you instant, keyboard-driven access to your workflows anywhere in WordPress.

    Type “ActivityPub” and you’ll see context-aware commands that adapt to your site setup and user role. Whether you’re managing a blog actor or a user actor, you can open followers and following lists, check blocked actors, jump straight to your settings, or even search and edit extra fields — all without ever leaving the Command Palette.

    A screenshot of the Command Palette in action.

    Every command includes the ActivityPub icon for easy recognition. Just press Cmd + K or Ctrl + K, start typing, and go — it’s the smoothest way yet to pilot your Fediverse setup.

    Stay in Sync Across the Fediverse

    Your follower lists now stay accurate wherever you connect.
    With support for Follower Synchronization (FEP-8fcf), the plugin automatically keeps your followers collection in step with other servers — even when things drift out of sync.

    If differences appear, background tasks quietly reconcile them, keeping your lists clean and consistent. The result is a smoother, more reliable experience across the entire Fediverse — no manual fixes required.

    Speed When It Counts

    Quoted posts and follow confirmations now move at the speed of conversation.

    A new immediate Accept dispatch system sends responses as soon as they’re created, instead of waiting for the next scheduled queue.

    That means faster follow confirmations and quicker quote acknowledgments, making interactions feel more natural across the Fediverse. Behind the scenes, those Accept messages go straight to the right inboxes — including mentioned and replied-to users — while a scheduled backup ensures full compatibility with slower servers.

    It’s a smart balance between speed and reliability, helping your posts and follows appear almost instantly.

    Privacy, Your Way

    Want to keep your social graph private? You can now hide your followers and following lists from public view while keeping all relationships intact. Your followers still follow — they’re just hidden when you prefer a little more privacy.

    Full ChangelogAddedAdd bidirectional transforms between reply and embed blocks for improved user experience.Add Command Palette integration for quick navigation to ActivityPub admin pagesAdded a new ap_object post type and taxonomies for storing and managing incoming ActivityPub objects, with updated handlersAdded a privacy option to hide followers and following lists from profiles while keeping follow relationships intact.Added a scheduled task and setting to automatically purge old inbox items, helping maintain site performance and storage control.Added fallback to trigger create handling when updates fail for missing posts or comments, ensuring objects are properly created.Added immediate dispatch for Accept activities to speed up quoted posts while keeping scheduled processing for compatibility with other instances.Added new configuration options to better manage traffic spikes when federating posts, allowing finer control over retry limits, delays, and batch pauses.Added support for FEP-8fcf follower synchronization, improving data consistency across servers with new sync headers, digest checks, and reconciliation tasks.Add LiteSpeed Cache integration to prevent ActivityPub JSON responses from being cached incorrectly. Includes automatic .htaccess rules and Site Health check to ensure proper configuration.Add quote visibility setting for Classic Editor users.Add unified attachment processor for handling ActivityPub media imports from both remote URLs and local files, with automatic media block generation and Classic Editor support.Integrate Federated Reply block with WP.com Reader’s post share functionality, allowing users to reply to ActivityPub posts directly from the Reader.ChangedAdded support for FEP-3b86 Activity Intents, extending WebFinger and REST interactions with new Create and Follow intent links.Added support for the latest NodeInfo (FEP-0151), with improved federation details, staff info, and software metadata for better ActivityPub compliance.Extended inbox support for undoing Like, Create, and Announce activities, with refactored undo logic and improved activity persistence.Improved Classic Editor integration by adding better media handling and full test coverage for attachments, permissions, and metadata.Improved delivery of public and follower activities by expanding local recipient handling to include all ActivityPub-capable users and follower collections.Improved inbox performance by batching and deduplicating activities, reducing redundant processing and improving handling during high activity periods.Improved REST API responses with smarter context handling.Improved REST collection pagination by using explicit total item counts for more accurate results.Moved default visibility handling from the server to the editor UI, ensuring consistent and flexible ActivityPub visibility settings across both block and classic editors.Prevented self-announcing by ignoring announces from the blog actor, while still processing announces from user and external actors.Refactored activity handling to support multiple recipients per activity, allowing posts and interactions to be linked to several local users at once.Refactored avatar handling into a new system that stores and manages avatars per remote actor, improving reliability and preparing for future caching support.Refactored the inbox system to use a shared inbox, storing activities once with multiple recipients for improved efficiency and reduced duplication.Reorganize integration loader and move Stream integration into dedicated folder structure.Reply posts: do not display post title before @mentions in posts that are replies to somebody elseSimplified configuration by always enabling the shared inbox and removing its separate setting, UI field, and related logic.Simplified inbox storage settings, allowing certain activities (like deletes) to be skipped to reduce unnecessary database use.Simplify follow() API return types to int|WP_Error for better predictability.Updated inbox handling to support multiple users receiving the same activity and improve overall data consistency.Updated mailer hooks to send notifications only when activities are successfully handled, preventing emails for failed events.Update plugin short description to be more user-friendly.FixedReply block now properly validates ActivityPub URLs before setting inReplyTo fieldAdded a safeguard to ensure the plugin works correctly even when no post types are selected.Added a safety check to prevent errors when resolving comment author hostnames without a valid IP address.Fixed activity processing to handle QuoteRequest and other edge cases more reliably.Fixed an issue with post content templates to ensure the correct fallback is always applied.Fixed fatal error when transformer Factory receives WP_Error objects.Fixed HTML entity encoding in extra field names when displayed on ActivityPub platformsFixed typo in example, improve quoting description.Fix Following table error message to display user input instead of empty string when webfinger lookup fails.Fix infinite recursion when storing remote actors with mentions in their biosFix local inbox delivery to use internal REST API instead of HTTP, enabling local follows and proper boost counting.Fix logic errors in Move handler: remove redundant assignment and fix variable name collision.Fix public key retrieval for GoToSocial profiles with path-based key URLs.Improved actor resolution by prioritizing blog actor detection before remote actor checks and refining home page URL handling.Improved handling of empty fields for better compatibility with Pixelfed and more consistent fallback behavior across actor names, URLs, and related data.Improved hashtag encoding for consistent formatting.Improved Jetpack integration by initializing it during the WordPress startup process.Refactored Mastodon import handling to use consistent array-based data, improving reliability and compatibility across all import scenarios.DownloadsWordPress.org: activitypub.7.6.0.zipGitHub: tag/7.6.0Thanks, Crew!

    Big thanks to everyone who contributed code, feedback, and testing to make this release possible. You keep ActivityPub evolving with every version.

    Version 7.6.0 is now live — update today and enjoy lightning-fast navigation, smarter synchronization, and smoother federation! ❤️

    read more
  • ishii00141@mastodon.socialundefined
    ishii00141@mastodon.social

    RE: https://ishii00141.stars.ne.jp/20251108-1916-3859/


    これを投稿した時は、日本語のハッシュタグはデコードされて表示されていたはず。
    今見たら…。
    これまでの投稿も全てデコードされずに表示される？

    read more
  • eclecticpassions@fosstodon.orgundefined
    eclecticpassions@fosstodon.org

    When I first started , I used the most popular , . If you've read my previous posts, you know I never got along with it—which is why I have my new love, 🥰.

    I haven't deleted it though, and I very occasionally post there. This is my latest:

    ➡️ https://eclecticpassions.net/blog/improve-personal-productivity-modified-eisenhower-matrix/

    One day, I'll convert it to a static site, but I haven't gotten the chance yet.

    Meanwhile, I installed the to see how it works... seems I can't get quoting to work.

    read more
  • gabboman@app.wafrn.netundefined
    gabboman@app.wafrn.net

    would sync follows and posts

    read more
  • zsoltsb@app.wafrn.netundefined
    zsoltsb@app.wafrn.net

    i did it by looking up my previous bsky accounts, and clicking through manually, lol. but a force sync could still be useful?

    read more
@pierobosio@soc.bosio.info
Post suggeriti
  • mobileatom@flipboard.comundefined

    Indieweb Update: Fediverse (ActivityPub) & Webmentions.

    General Discussion fediverse activitypub
    1
    0 Votes
    1 Posts
    2 Views
    mobileatom@flipboard.comundefined
    Indieweb Update: Fediverse (ActivityPub) & Webmentions. #fediverse #activityPubhttps://schlitt.info/blog/0789_indieweb_update_fediverse_activitypub_webmention.html?utm_source=flipboard&utm_medium=activitypub Posted into THE FEDIVERSE VS. CORPORATE SOCIAL MEDIA @the-fediverse-vs-corporate-social-media-mobileatom
  • novatopflex.wordpress.com@novatopflex.wordpress.comundefined

    The Philosophical Debates (Kay-Kingsbury Edition)

    General Discussion activism activitypub arguments culture debates fediverse identity mastodon
    1
    0 Votes
    1 Posts
    13 Views
    novatopflex.wordpress.com@novatopflex.wordpress.comundefined
    Andrew Kay (novaTopFlex) is currently in multiple ongoing philosophical arguments involving Alexander Kingsbury, Mojo, and MrLee on Mastodon, all under a common core of shared beliefs for—or against—capitalism. While novaTopFlex fears infinite growth and the criminalization of genuine friendship and authenticity as well as forced conformity to traditional roles in society, Kingsbury claims that capitalism contains no demands for infinite growth nor for related concerns. In addition, Mojo and MrLee have identified common concerns regarding the erosion of community and empathy in a society that prides wealth accumulation as “success.”
  • wjmaggos@liberal.cityundefined

    Would you like to see full default interoperability between #ATproto and #ActivityPub without a bridge?

    General Discussion atproto activitypub
    47
    0 Votes
    47 Posts
    86 Views
    quillmatiq@mastodon.socialundefined
    @wjmaggos @evan @chris @blaine @anewsocial Huge difference between screenshotting vs always being a part of another network and another organization's infrastructure by default.To be clear, I don't agree with Fediverse platforms depending on a blocklists, I much prefer approve-lists, but I don't think that's a popular opinion either.
  • cocoa@hackers.pubundefined

    How to Build a Simple ActivityPub Reminder Bot in Python

    Uncategorized activitypub python apkit
    1
    0 Votes
    1 Posts
    15 Views
    cocoa@hackers.pubundefined
    This tutorial will guide you through building a simple ActivityPub bot using Python. The bot will listen for mentions and, when it receives a message in a specific format, it will schedule and send a reminder back to the user after a specified delay. For example, if a user mentions the bot with a message like "@reminder@your.host.com 10m check the oven", the bot will reply 10 minutes later with a message like "🔔 Reminder for @user: check the oven". Prerequisites To follow this tutorial, you will need Python 3.10+ and the following libraries: apkit[server]: A powerful toolkit for building ActivityPub applications in Python. We use the server extra, which includes FastAPI-based components. uvicorn: An ASGI server to run our FastAPI application. cryptography: Used for generating and managing the cryptographic keys required for ActivityPub. uv: An optional but recommended fast package manager. You can install these dependencies using uv or pip. # Initialize a new project with uv uv init # Install dependencies uv add "apkit[server]" uvicorn cryptography Project Structure The project structure is minimal, consisting of a single Python file for our bot's logic. . ├── main.py └── private_key.pem main.py: Contains all the code for the bot. private_key.pem: The private key for the bot's Actor. This will be generated automatically on the first run. Code Walkthrough Our application logic can be broken down into the following steps: Imports and Configuration: Set up necessary imports and basic configuration variables. Key Generation: Prepare the cryptographic keys needed for signing activities. Actor Definition: Define the bot's identity on the Fediverse. Server Initialization: Set up the apkit ActivityPub server. Data Storage: Implement a simple in-memory store for created activities. Reminder Logic: Code the core logic for parsing reminders and sending notifications. Endpoint Definitions: Create the necessary web endpoints (/actor, /inbox, etc.). Activity Handlers: Process incoming activities from other servers. Application Startup: Run the server. Let's dive into each section of the main.py file. 1. Imports and Configuration First, we import the necessary modules and define the basic configuration for our bot. # main.py import asyncio import logging import re import uuid import os from datetime import timedelta, datetime # Imports from FastAPI, cryptography, and apkit from fastapi import Request, Response from fastapi.responses import JSONResponse from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization as crypto_serialization from apkit.config import AppConfig from apkit.server import ActivityPubServer from apkit.server.types import Context, ActorKey from apkit.server.responses import ActivityResponse from apkit.models import ( Actor, Application, CryptographicKey, Follow, Create, Note, Mention, Actor as APKitActor, OrderedCollection, ) from apkit.client import WebfingerResource, WebfingerResult, WebfingerLink from apkit.client.asyncio.client import ActivityPubClient # --- Logging Setup --- logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # --- Basic Configuration --- HOST = "your.host.com" # Replace with your domain USER_ID = "reminder" # The bot's username Make sure to replace your.host.com with the actual domain where your bot will be hosted. These values determine your bot's unique identifier (e.g., @reminder@your.host.com). 2. Key Generation and Persistence ActivityPub uses HTTP Signatures to secure communication between servers. This requires each actor to have a public/private key pair. The following code generates a private key and saves it to a file if one doesn't already exist. # main.py (continued) # --- Key Persistence --- KEY_FILE = "private_key.pem" # Load the private key if it exists, otherwise generate a new one if os.path.exists(KEY_FILE): logger.info(f"Loading existing private key from {KEY_FILE}.") with open(KEY_FILE, "rb") as f: private_key = crypto_serialization.load_pem_private_key(f.read(), password=None) else: logger.info(f"No key file found. Generating new private key and saving to {KEY_FILE}.") private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048) with open(KEY_FILE, "wb") as f: f.write(private_key.private_bytes( encoding=crypto_serialization.Encoding.PEM, format=crypto_serialization.PrivateFormat.PKCS8, encryption_algorithm=crypto_serialization.NoEncryption() )) # Generate the public key from the private key public_key_pem = private_key.public_key().public_bytes( encoding=crypto_serialization.Encoding.PEM, format=crypto_serialization.PublicFormat.SubjectPublicKeyInfo ).decode('utf-8') 3. Actor Definition Next, we define the bot's Actor. The Actor is the bot's identity in the ActivityPub network. We use the Application type, as this entity is automated. # main.py (continued) # --- Actor Definition --- actor = Application( id=f"https://{HOST}/actor", name="Reminder Bot", preferredUsername=USER_ID, summary="A bot that sends you reminders. Mention me like: @reminder 5m Check the oven", inbox=f"https://{HOST}/inbox", # Endpoint for receiving activities outbox=f"https://{HOST}/outbox", # Endpoint for sending activities publicKey=CryptographicKey( id=f"https://{HOST}/actor#main-key", owner=f"https://{HOST}/actor", publicKeyPem=public_key_pem ) ) 4. Server Initialization We initialize the ActivityPubServer from apkit, providing it with a function to retrieve our Actor's keys for signing outgoing activities. # main.py (continued) # --- Key Retrieval Function --- async def get_keys_for_actor(identifier: str) -> list[ActorKey]: """Returns the key for a given Actor ID.""" if identifier == actor.id: return [ActorKey(key_id=actor.publicKey.id, private_key=private_key)] return [] # --- Server Initialization --- app = ActivityPubServer(apkit_config=AppConfig( actor_keys=get_keys_for_actor # Register the key retrieval function )) 5. In-Memory Storage and Cache To serve created activities, we need to store them somewhere. For simplicity, this example uses a basic in-memory dictionary as a store and a cache. In a production application, you would replace this with a persistent database (like SQLite or PostgreSQL) and a proper cache (like Redis). # main.py (continued) # --- In-memory Store and Cache --- ACTIVITY_STORE = {} # A simple dict to store created activities CACHE = {} # A cache for recently accessed activities CACHE_TTL = timedelta(minutes=5) # Cache expiration time (5 minutes) 6. Reminder Parsing and Sending Logic This is the core logic of our bot. The parse_reminder function uses a regular expression to extract the delay and message from a mention, and send_reminder schedules the notification. # main.py (continued) # --- Reminder Parsing Logic --- def parse_reminder(text: str) -> tuple[timedelta | None, str | None, str | None]: """Parses reminder text like '5m do something'.""" # ... (implementation omitted for brevity) # --- Reminder Sending Function --- async def send_reminder(ctx: Context, delay: timedelta, message: str, target_actor: APKitActor, original_note: Note): """Waits for a specified delay and then sends a reminder.""" logger.info(f"Scheduling reminder for {target_actor.id} in {delay}: '{message}'") await asyncio.sleep(delay.total_seconds()) # Asynchronously wait logger.info(f"Sending reminder to {target_actor.id}") # Create the reminder Note reminder_note = Note(...) # Wrap it in a Create activity reminder_create = Create(...) # Store the created activities ACTIVITY_STORE[reminder_note.id] = reminder_note ACTIVITY_STORE[reminder_create.id] = reminder_create # Send the activity to the target actor's inbox keys = await get_keys_for_actor(f"https://{HOST}/actor") await ctx.send(keys, target_actor, reminder_create) logger.info(f"Reminder sent to {target_actor.id}") 7. Endpoint Definitions We define the required ActivityPub endpoints. Since apkit is built on FastAPI, we can use standard FastAPI decorators. The main endpoints are: Webfinger: Allows users on other servers to discover the bot using an address like @user@host. This is a crucial first step for federation. /actor: Serves the bot's Actor object, which contains its profile information and public key. /inbox: The endpoint where the bot receives activities from other servers. apkit handles this route automatically, directing activities to the handlers we'll define in the next step. /outbox: A collection of the activities created by the bot. but this returns placeholder collection. /notes/{note_id} and /creates/{create_id}: Endpoints to serve specific objects created by the bot, allowing other servers to fetch them by their unique ID. Here is the code for defining these endpoints: # main.py (continued) # The inbox endpoint is handled by apkit automatically. app.inbox("/inbox") @app.webfinger() async def webfinger_endpoint(request: Request, acct: WebfingerResource) -> Response: """Handles Webfinger requests to make the bot discoverable.""" if not acct.url: # Handle resource queries like acct:user@host if acct.username == USER_ID and acct.host == HOST: link = WebfingerLink(rel="self", type="application/activity+json", href=actor.id) wf_result = WebfingerResult(subject=acct, links=[link]) return JSONResponse(wf_result.to_json(), media_type="application/jrd+json") else: # Handle resource queries using a URL if acct.url == f"https://{HOST}/actor": link = WebfingerLink(rel="self", type="application/activity+json", href=actor.id) wf_result = WebfingerResult(subject=acct, links=[link]) return JSONResponse(wf_result.to_json(), media_type="application/jrd+json") return JSONResponse({"message": "Not Found"}, status_code=404) @app.get("/actor") async def get_actor_endpoint(): """Serves the bot's Actor object.""" return ActivityResponse(actor) @app.get("/outbox") async def get_outbox_endpoint(): """Serves a collection of the bot's sent activities.""" items = sorted(ACTIVITY_STORE.values(), key=lambda x: x.id, reverse=True) outbox_collection = OrderedCollection( id=actor.outbox, totalItems=len(items), orderedItems=items ) return ActivityResponse(outbox_collection) @app.get("/notes/{note_id}") async def get_note_endpoint(note_id: uuid.UUID): """Serves a specific Note object, with caching.""" note_uri = f"https://{HOST}/notes/{note_id}" # Check cache first if note_uri in CACHE and (datetime.now() - CACHE[note_uri]["timestamp"]) < CACHE_TTL: return ActivityResponse(CACHE[note_uri]["activity"]) # If not in cache, get from store if note_uri in ACTIVITY_STORE: activity = ACTIVITY_STORE[note_uri] # Add to cache before returning CACHE[note_uri] = {"activity": activity, "timestamp": datetime.now()} return ActivityResponse(activity) return Response(status_code=404) # Not Found @app.get("/creates/{create_id}") async def get_create_endpoint(create_id: uuid.UUID): """Serves a specific Create activity, with caching.""" create_uri = f"https://{HOST}/creates/{create_id}" if create_uri in CACHE and (datetime.now() - CACHE[create_uri]["timestamp"]) < CACHE_TTL: return ActivityResponse(CACHE[create_uri]["activity"]) if create_uri in ACTIVITY_STORE: activity = ACTIVITY_STORE[create_uri] CACHE[create_uri] = {"activity": activity, "timestamp": datetime.now()} return ActivityResponse(activity) return Response(status_code=404) 8. Activity Handlers We use the @app.on() decorator to define handlers for specific activity types posted to our inbox. on_follow_activity: Automatically accepts Follow requests. on_create_activity: Parses incoming Create activities (specifically for Note objects) to schedule reminders. # main.py (continued) # Handler for Follow activities @app.on(Follow) async def on_follow_activity(ctx: Context): """Automatically accepts follow requests.""" # ... (implementation omitted for brevity) # Handler for Create activities @app.on(Create) async def on_create_activity(ctx: Context): """Parses mentions to schedule reminders.""" activity = ctx.activity # Ignore if it's not a Note if not (isinstance(activity, Create) and isinstance(activity.object, Note)): return Response(status_code=202) note = activity.object # Check if the bot was mentioned is_mentioned = any( isinstance(tag, Mention) and tag.href == actor.id for tag in (note.tag or []) ) if not is_mentioned: return Response(status_code=202) # ... (Parse reminder text) delay, message, time_str = parse_reminder(command_text) # If parsing is successful, schedule the reminder as a background task if delay and message and sender_actor: asyncio.create_task(send_reminder(ctx, delay, message, sender_actor, note)) reply_content = f"<p>✅ OK! I will remind you in {time_str}.</p>" else: # If parsing fails, send usage instructions reply_content = "<p>🤔 Sorry, I didn\'t understand. Please use the format: `@reminder [time] [message]`.</p><p>Example: `@reminder 10m Check the oven`</p>" # ... (Create and send the reply Note) 9. Running the Application Finally, we run the application using uvicorn. # main.py (continued) if __name__ == "__main__": import uvicorn logger.info("Starting uvicorn server...") uvicorn.run(app, host="0.0.0.0", port=8000) How to Run the Bot Set the HOST and USER_ID variables in main.py to match your environment. Run the server from your terminal: uvicorn main:app --host 0.0.0.0 --port 8000 Your bot will be running at http://0.0.0.0:8000. Now you can mention your bot from anywhere in the Fediverse (e.g., @reminder@your.host.com) to set a reminder. Next Steps This tutorial covers the basics of creating a simple ActivityPub bot. Since it only uses in-memory storage, all reminders will be lost on server restart. Here are some potential improvements: Persistent Storage: Replace the in-memory ACTIVITY_STORE with a database like SQLite or PostgreSQL. Robust Task Queuing: Use a dedicated task queue like Celery with a Redis or RabbitMQ broker to ensure reminders are not lost if the server restarts. Advanced Commands: Add support for more complex commands, such as recurring reminders. We hope this guide serves as a good starting point for building your own ActivityPub applications! https://fedi-libs.github.io/apkit/ https://github.com/fedi-libs/apkit https://github.com/AmaseCocoa/activitypub-reminder-bot