@fedify/vocab 2.4.0-pr.936.41 → 2.4.0

package/src/actor.test.ts

@@ -99,45 +99,46 @@ test({
   async fn(t) {
     fetchMock.spyGlobal();
 
+    // Node validates addresses before fetch; public IP literals avoid DNS.
     fetchMock.get(
-      "begin:https://foo.example.com/.well-known/webfinger?",
+      "begin:https://1.1.1.1/.well-known/webfinger?",
       {
-        body: { subject: "acct:johndoe@foo.example.com" },
+        body: { subject: "acct:johndoe@1.1.1.1" },
         headers: { "Content-Type": "application/jrd+json" },
       },
     );
 
-    const actorId = new URL("https://foo.example.com/@john");
+    const actorId = new URL("https://1.1.1.1/@john");
     const actor = new Person({
       id: actorId,
       preferredUsername: "john",
     });
 
     await t.step("WebFinger subject", async () => {
-      deepStrictEqual(await getActorHandle(actor), "@johndoe@foo.example.com");
+      deepStrictEqual(await getActorHandle(actor), "@johndoe@1.1.1.1");
       deepStrictEqual(
         await getActorHandle(actor, { trimLeadingAt: true }),
-        "johndoe@foo.example.com",
+        "johndoe@1.1.1.1",
       );
       deepStrictEqual(
         await getActorHandle(actorId),
-        "@johndoe@foo.example.com",
+        "@johndoe@1.1.1.1",
       );
       deepStrictEqual(
         await getActorHandle(actorId, { trimLeadingAt: true }),
-        "johndoe@foo.example.com",
+        "johndoe@1.1.1.1",
       );
     });
 
     fetchMock.removeRoutes();
     fetchMock.get(
-      "begin:https://foo.example.com/.well-known/webfinger?",
+      "begin:https://1.1.1.1/.well-known/webfinger?",
       {
         body: {
-          subject: "https://foo.example.com/@john",
+          subject: "https://1.1.1.1/@john",
           aliases: [
-            "acct:john@bar.example.com",
-            "acct:johndoe@foo.example.com",
+            "acct:john@8.8.8.8",
+            "acct:johndoe@1.1.1.1",
           ],
         },
         headers: { "Content-Type": "application/jrd+json" },
@@ -145,28 +146,28 @@ test({
     );
 
     await t.step("WebFinger aliases", async () => {
-      deepStrictEqual(await getActorHandle(actor), "@johndoe@foo.example.com");
+      deepStrictEqual(await getActorHandle(actor), "@johndoe@1.1.1.1");
       deepStrictEqual(
         await getActorHandle(actor, { trimLeadingAt: true }),
-        "johndoe@foo.example.com",
+        "johndoe@1.1.1.1",
       );
       deepStrictEqual(
         await getActorHandle(actorId),
-        "@johndoe@foo.example.com",
+        "@johndoe@1.1.1.1",
       );
       deepStrictEqual(
         await getActorHandle(actorId, { trimLeadingAt: true }),
-        "johndoe@foo.example.com",
+        "johndoe@1.1.1.1",
       );
     });
 
     fetchMock.get(
-      "begin:https://bar.example.com/.well-known/webfinger?",
+      "begin:https://8.8.8.8/.well-known/webfinger?",
       {
         body: {
-          subject: "acct:john@bar.example.com",
+          subject: "acct:john@8.8.8.8",
           aliases: [
-            "https://foo.example.com/@john",
+            "https://1.1.1.1/@john",
           ],
         },
         headers: { "Content-Type": "application/jrd+json" },
@@ -174,18 +175,18 @@ test({
     );
 
     await t.step("cross-origin WebFinger resources", async () => {
-      deepStrictEqual(await getActorHandle(actor), "@john@bar.example.com");
+      deepStrictEqual(await getActorHandle(actor), "@john@8.8.8.8");
     });
 
     fetchMock.removeRoutes();
     fetchMock.get(
-      "begin:https://foo.example.com/.well-known/webfinger?",
+      "begin:https://1.1.1.1/.well-known/webfinger?",
       { status: 404 },
     );
 
     await t.step("no WebFinger", async () => {
-      deepStrictEqual(await getActorHandle(actor), "@john@foo.example.com");
-      rejects(() => getActorHandle(actorId), TypeError);
+      deepStrictEqual(await getActorHandle(actor), "@john@1.1.1.1");
+      await rejects(() => getActorHandle(actorId), TypeError);
     });
 
     fetchMock.hardReset();
@@ -197,7 +198,7 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
 }, async (t) => {
   fetchMock.spyGlobal();
   try {
-    const actorId = new URL("https://foo.example.com/@john");
+    const actorId = new URL("https://1.1.1.1/@john");
     const actor = new Person({
       id: actorId,
       preferredUsername: "john",
@@ -206,15 +207,15 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
     await t.step("records result=resolved on a successful lookup", async () => {
       fetchMock.removeRoutes();
       fetchMock.get(
-        "begin:https://foo.example.com/.well-known/webfinger?",
+        "begin:https://1.1.1.1/.well-known/webfinger?",
         {
-          body: { subject: "acct:johndoe@foo.example.com" },
+          body: { subject: "acct:johndoe@1.1.1.1" },
           headers: { "Content-Type": "application/jrd+json" },
         },
       );
       const [meterProvider, recorder] = createTestMeterProvider();
       const handle = await getActorHandle(actor, { meterProvider });
-      deepStrictEqual(handle, "@johndoe@foo.example.com");
+      deepStrictEqual(handle, "@johndoe@1.1.1.1");
 
       const counters = recorder.getMeasurements(
         "activitypub.actor.discovery",
@@ -228,7 +229,7 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
       );
       deepStrictEqual(
         counters[0].attributes["activitypub.remote.host"],
-        "foo.example.com",
+        "1.1.1.1",
       );
 
       const durations = recorder.getMeasurements(
@@ -248,12 +249,12 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
       async () => {
         fetchMock.removeRoutes();
         fetchMock.get(
-          "begin:https://foo.example.com/.well-known/webfinger?",
+          "begin:https://1.1.1.1/.well-known/webfinger?",
           { status: 404 },
         );
         const [meterProvider, recorder] = createTestMeterProvider();
         const handle = await getActorHandle(actor, { meterProvider });
-        deepStrictEqual(handle, "@john@foo.example.com");
+        deepStrictEqual(handle, "@john@1.1.1.1");
         const counter = recorder.getMeasurement("activitypub.actor.discovery");
         ok(counter != null);
         deepStrictEqual(
@@ -268,7 +269,7 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
       async () => {
         fetchMock.removeRoutes();
         fetchMock.get(
-          "begin:https://foo.example.com/.well-known/webfinger?",
+          "begin:https://1.1.1.1/.well-known/webfinger?",
           { status: 404 },
         );
         const [meterProvider, recorder] = createTestMeterProvider();
@@ -284,7 +285,7 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
         );
         deepStrictEqual(
           counter.attributes["activitypub.remote.host"],
-          "foo.example.com",
+          "1.1.1.1",
         );
         const duration = recorder.getMeasurement(
           "activitypub.actor.discovery.duration",
@@ -302,13 +303,13 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
       async () => {
         fetchMock.removeRoutes();
         fetchMock.get(
-          "begin:https://foo.example.com:8443/.well-known/webfinger?",
+          "begin:https://1.1.1.1:8443/.well-known/webfinger?",
           { status: 404 },
         );
         const [meterProvider, recorder] = createTestMeterProvider();
         await rejects(
           () =>
-            getActorHandle(new URL("https://foo.example.com:8443/@john"), {
+            getActorHandle(new URL("https://1.1.1.1:8443/@john"), {
               meterProvider,
             }),
           TypeError,
@@ -317,7 +318,7 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
         ok(counter != null);
         deepStrictEqual(
           counter.attributes["activitypub.remote.host"],
-          "foo.example.com:8443",
+          "1.1.1.1:8443",
         );
       },
     );
@@ -332,10 +333,10 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
         // `error` rather than `not_found`.
         fetchMock.removeRoutes();
         fetchMock.get(
-          "begin:https://foo.example.com/.well-known/webfinger?",
+          "begin:https://1.1.1.1/.well-known/webfinger?",
           {
             body: {
-              subject: "https://foo.example.com/@john",
+              subject: "https://1.1.1.1/@john",
               aliases: ["acct:john@["],
             },
             headers: { "Content-Type": "application/jrd+json" },
@@ -362,9 +363,9 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
       async () => {
         fetchMock.removeRoutes();
         fetchMock.get(
-          "begin:https://foo.example.com/.well-known/webfinger?",
+          "begin:https://1.1.1.1/.well-known/webfinger?",
           {
-            body: { subject: "acct:johndoe@foo.example.com" },
+            body: { subject: "acct:johndoe@1.1.1.1" },
             headers: { "Content-Type": "application/jrd+json" },
           },
         );
@@ -384,9 +385,9 @@ test("getActorHandle() records activitypub.actor.discovery counter", {
       async () => {
         fetchMock.removeRoutes();
         fetchMock.get(
-          "begin:https://foo.example.com/.well-known/webfinger?",
+          "begin:https://1.1.1.1/.well-known/webfinger?",
           {
-            body: { subject: "acct:johndoe@foo.example.com" },
+            body: { subject: "acct:johndoe@1.1.1.1" },
             headers: { "Content-Type": "application/jrd+json" },
           },
         );

package/src/actor.ts

@@ -1,5 +1,11 @@
 import type { GetUserAgentOptions } from "@fedify/vocab-runtime";
-import { lookupWebFinger } from "@fedify/webfinger";
+import {
+  canonicalizePortableUri,
+  formatIri,
+  fromCompatibleEf61Id,
+  isGatewayUrl,
+} from "@fedify/vocab-runtime";
+import { lookupWebFinger, type ResourceDescriptor } from "@fedify/webfinger";
 import {
   type Attributes,
   type Counter,
@@ -93,6 +99,11 @@ function getActorDiscoveryRemoteHost(
 ): string | undefined {
   const id = actor instanceof URL ? actor : actor.id;
   if (id == null) return undefined;
+  // The authority of a portable ID is a DID, not a host; the handle of
+  // a portable actor comes from its first gateway:
+  if (isPortableActorId(id)) {
+    return actor instanceof URL ? undefined : actor.gateway?.host;
+  }
   return id.host === "" ? undefined : id.host;
 }
 
@@ -234,6 +245,17 @@ export interface GetActorHandleOptions extends NormalizeActorHandleOptions {
  * await getActorHandle(new URL("https://fosstodon.org/users/hongminhee"));
  * ```
  *
+ * For an [FEP-ef61] portable actor, whose ID is an `ap:` or `ap+ef61:` URI,
+ * the domain is taken from the first gateway in the actor's `gateways` rather
+ * than from its ID.  The handle is returned only if its WebFinger response
+ * links back to the actor, since the actor's `gateways` are claimed by the
+ * actor itself; a failed WebFinger lookup is not enough information to get
+ * the handle.  A portable actor without `gateways` or
+ * `preferredUsername`, or a portable actor URI (which does not tell its
+ * gateways), is not supported.
+ *
+ * [FEP-ef61]: https://w3id.org/fep/ef61
+ *
  * @param actor The actor or actor URI to get the handle from.
  * @param options The extra options for getting the actor handle.
  * @returns The actor handle.  It starts with `@` and is followed by the
@@ -302,6 +324,10 @@ async function getActorHandleInternal(
   options: GetActorHandleOptions = {},
 ): Promise<`@${string}@${string}` | `${string}@${string}`> {
   const actorId = actor instanceof URL ? actor : actor.id;
+  if (actorId != null && isPortableActorId(actorId)) {
+    if (actor instanceof URL) throw new ActorHandleNotFoundError();
+    return await getPortableActorHandle(actor, actorId, options);
+  }
   if (actorId != null) {
     const result = await lookupWebFinger(actorId, {
       userAgent: options.userAgent,
@@ -344,6 +370,89 @@ async function getActorHandleInternal(
   throw new ActorHandleNotFoundError();
 }
 
+function isPortableActorId(id: URL): boolean {
+  return id.protocol === "ap:" || id.protocol === "ap+ef61:";
+}
+
+/**
+ * The reverse discovery of an FEP-ef61 portable actor's WebFinger address,
+ * which takes the domain from the first gateway in its `gateways`.
+ */
+async function getPortableActorHandle(
+  actor: Actor,
+  actorId: URL,
+  options: GetActorHandleOptions,
+): Promise<`@${string}@${string}` | `${string}@${string}`> {
+  const gateway = actor.gateway;
+  const username = actor.preferredUsername?.toString();
+  if (gateway == null || !isGatewayUrl(gateway) || username == null) {
+    throw new ActorHandleNotFoundError();
+  }
+  const canonicalId = canonicalizePortableUri(formatIri(actorId));
+  const handle = `acct:${username}@${gateway.host}`;
+  const result = await lookupWebFinger(handle, {
+    userAgent: options.userAgent,
+    tracerProvider: options.tracerProvider,
+    meterProvider: options.meterProvider,
+  });
+  // Unlike an ordinary actor, whose ID vouches for its host, a portable
+  // actor's gateways are claimed by the actor itself, so there is no
+  // fallback when the gateway does not link back to the actor:
+  if (result == null || !linksToPortableActor(result, canonicalId)) {
+    throw new ActorHandleNotFoundError();
+  }
+  // The subject is the canonical address when it differs from the queried
+  // one; follow it once if it also links back to the actor:
+  const subject = result.subject?.match(/^acct:([^@]+)@([^@]+)$/);
+  if (subject != null && result.subject !== handle) {
+    const subjectResult = await lookupWebFinger(result.subject!, {
+      userAgent: options.userAgent,
+      tracerProvider: options.tracerProvider,
+      meterProvider: options.meterProvider,
+    });
+    if (
+      subjectResult != null && linksToPortableActor(subjectResult, canonicalId)
+    ) {
+      return normalizeActorHandle(`@${subject[1]}@${subject[2]}`, options);
+    }
+  }
+  return normalizeActorHandle(`@${username}@${gateway.host}`, options);
+}
+
+/**
+ * Checks if the first ActivityStreams `self` link of a WebFinger response
+ * identifies the portable actor, either by its portable ID or by
+ * a compatible identifier.
+ */
+function linksToPortableActor(
+  jrd: ResourceDescriptor,
+  canonicalId: string,
+): boolean {
+  const link = jrd.links?.find((l) =>
+    l.rel === "self" && l.href != null &&
+    (l.type === "application/activity+json" ||
+      l.type?.match(
+          /application\/ld\+json;\s*profile="https:\/\/www.w3.org\/ns\/activitystreams"/,
+        ) != null)
+  );
+  if (link?.href == null) return false;
+  try {
+    let id: string;
+    if (/^ap(?:\+ef61)?:/i.test(link.href)) id = link.href;
+    else {
+      const portable = URL.canParse(link.href)
+        ? fromCompatibleEf61Id(link.href)
+        : null;
+      if (portable == null) return false;
+      id = formatIri(portable);
+    }
+    return canonicalizePortableUri(id) === canonicalId;
+  } catch (error) {
+    if (error instanceof TypeError) return false;
+    throw error;
+  }
+}
+
 async function verifyCrossOriginActorHandle(
   actorId: string,
   alias: string,
@@ -432,4 +541,14 @@ export interface Recipient {
      */
     readonly sharedInbox: URL | null;
   } | null;
+
+  /**
+   * The [FEP-ef61] gateways of the actor, in order, if it is a portable actor.
+   * Activities to a portable inbox, i.e., an `ap:` or `ap+ef61:` URI, are
+   * delivered to the inbox's compatible identifier on one of these gateways.
+   *
+   * [FEP-ef61]: https://w3id.org/fep/ef61
+   * @since 2.4.0
+   */
+  readonly gateways?: readonly URL[];
 }