From ff666938b0430ddc3b135474f07e6d98ce83fd24 Mon Sep 17 00:00:00 2001 From: Evan Pratten Date: Tue, 17 Jan 2023 15:21:18 -0500 Subject: [PATCH] mstdn search post --- content/blog/2023-01-17-webfinger-redir.md | 159 +++++++++++++++++++++ 1 file changed, 159 insertions(+) create mode 100644 content/blog/2023-01-17-webfinger-redir.md diff --git a/content/blog/2023-01-17-webfinger-redir.md b/content/blog/2023-01-17-webfinger-redir.md new file mode 100644 index 0000000..c5a1031 --- /dev/null +++ b/content/blog/2023-01-17-webfinger-redir.md @@ -0,0 +1,159 @@ +--- +layout: page +title: "Lazy search for Mastodon accounts" +description: "Webfinger + Cloudflare Workers + Firefox custom search engines" +date: 2023-01-17 +tags: project +draft: false +extra: + auto_center_images: true + excerpt: "I made a custom search prefix for my browser that can resolve ActivityPub accounts into their profile pages" +--- + +Anyone who has been using Mastodon (or other ActivityPub servers) for a bit might have noticed how its a little annoying to look up someone's "home profile" from their account handle. My personal flow goes something like: + +1. Open my own mastodon instance +2. Search the other user's handle +3. Find the account in the results +4. Use the `Open original page` button to jump to their full profile + +Luckily, with a little bit of server-side tinkering, this process can be cut down to a single step: + +1. Search the user's handle in my browser searchbar + +## A bit of background + +Most (notable) decentralized social media services are built on a web standard called [ActivityPub](https://www.w3.org/TR/activitypub/). ActivityPub handles all aspects of cross-instance communication, including the process of looking up users on another instance. + +This cross-instance user lookup system utilizes [RFC7033: WebFinger](https://www.rfc-editor.org/rfc/rfc7033), a modern replacement / reimplementation of the old [RFC742: Name/Finger](https://www.rfc-editor.org/rfc/rfc742) protocol. + +For example, if you wanted some information about my personal `@evan@ewpratten.com` account, you can send an HTTP GET request to the following URL: + +```text +https://ewpratten.com/.well-known/webfinger?resource=acct:evan@ewpratten.com +``` + +..and you'll get back a response that looks something like this: + +```json +{ + "subject": "acct:evan@ewpratten.com", + "aliases": [ + "https://social.ewpratten.com/@evan", + "https://social.ewpratten.com/users/evan" + ], + "links": [ + { + "rel": "http://webfinger.net/rel/profile-page", + "type": "text/html", + "href": "https://social.ewpratten.com/@evan" + }, + { + "rel": "self", + "type": "application/activity+json", + "href": "https://social.ewpratten.com/users/evan" + }, + { + "rel": "http://ostatus.org/schema/1.0/subscribe", + "template": "https://social.ewpratten.com/authorize_interaction?uri={uri}" + } + ] +} +``` + +Notice the `links[0].href` field above? This is exactly the URL for my profile page, on my home instance! + +## Plan of action + +Now that we know how to get a profile's "home" URL via WebFinger, we can write a little script to convert an account handle query into a [302 redirect](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/302) to that account's URL. + +The plan is to make a query like: + +```text +GET https://mastodon-redirect.example.com/profile/@evan@ewpratten.com +``` + +and get a repsonse of: + +```text +HTTP/1.1 302 Found +Location: https://social.ewpratten.com/@evan +``` + +## Implementing the redirect script + +I chose to do this with a [Cloudflare Worker](https://workers.cloudflare.com/), since my domains are already managed by them, and I have free credits to use. + +The script to get this working is pretty simple: + +```js +export default { + async fetch(request, env) { + try { + const { pathname } = new URL(request.url); + + // If the root is hit, return a basic info page + if (pathname == "/" || pathname == "") { + return new Response("This is a webfinger redirect service."); + } + + // Put together common info other functions may need + let profile = pathname.split("/profile").reverse()[0].replaceAll("%40", "@").replace("/@", "").replace("/", ""); + let domain = profile.split("@").reverse()[0]; + let webfinger_url = `https://${domain}/.well-known/webfinger?resource=acct:${profile}`; + + // Handle profile redirects + if (pathname.startsWith("/profile")) { + + // Make a request to the webfinger url for JSON data + let response = await fetch(webfinger_url); + + // If the response fails, return in + if (!response.ok){ + return response; + } + let response_json = await response.json(); + + // Parse the profile url out of the response + let profile_url = null; + for (let i = 0; i < response_json.links.length; i++){ + if (response_json.links[i]["rel"] == "http://webfinger.net/rel/profile-page"){ + profile_url = response_json.links[i]["href"]; + break + } + } + + // Handle the response + if (profile_url) { + return new Response("", { + status: 302, + headers: { + "Location": profile_url + } + }) + } else { + return new Response("Could not find a profile-page link for this profile", {status: 404}); + } + } + } catch(e) { + return new Response(e.stack, { status: 500 }) + } + } +} +``` + +For the rest of this post, I'll assume you have this hosted at `mastodon-redirect.example.com`. + +## Tying everything together with a Firefox search prefix + +*Note: This probably also works in Chromium-based browsers. I just don't remember the details of how* + +Firefox lets users set a prefix on their bookmarks. With a prefix set, you can search things with `@yourprefix This is a thing`, and the browser will string-substitute `This is a thing` into the bookmark url. Its a handy way to trigger a search inside a specific website without first opening that site. + +To set up a search prefix for the redirect service, we need to do the following: + +1. Create a new bookmark +2. Set the url to `https://mastodon-redirect.example.com/profile/%s` +3. Set the prefix to `@mastodon` (or whatever else you want) + +Finally, you can search `@mastodon @evan@ewpratten.com` in your searchbar, and you'll end up on my profile page! \ No newline at end of file