fedipod 1.48.0 → 1.48.1

package/web/app/dist/sw.js

@@ -9792,13 +9792,15 @@ function hostMeta(base) {
 </XRD>
 `;
 }
-function jrd({ handle: handle7, host, actor, aliases = [], page: page2 = null }) {
+function jrd({ handle: handle7, host, actor, aliases = [], page: page2 = null, avatar = null }) {
   return {
     subject: `acct:${handle7}@${host}`,
     ...aliases.length ? { aliases } : {},
     links: [
       { rel: "self", type: "application/activity+json", href: actor },
-      ...page2 ? [{ rel: "http://webfinger.net/rel/profile-page", type: "text/html", href: page2 }] : []
+      ...page2 ? [{ rel: "http://webfinger.net/rel/profile-page", type: "text/html", href: page2 }] : [],
+      // The account's picture, as Mastodon's answer names it.
+      ...avatar ? [{ rel: "http://webfinger.net/rel/avatar", href: avatar }] : []
     ]
   };
 }
@@ -34462,6 +34464,24 @@ async function register(pod, indexUrl, actorUrl) {
   if (status2 >= 300) throw new Error(`the type index at ${indexUrl} did not take the registration (${status2})`);
   return true;
 }
+async function unregister(pod, indexUrl, actorUrl) {
+  const g = await pod.readRdf(indexUrl);
+  if (!g) return false;
+  const actor = pod.sym(actorUrl);
+  const instance = pod.sym(SOLID + "instance");
+  const gone = [];
+  for (const reg of g.each(null, instance, actor)) {
+    if (!g.holds(reg, pod.sym(SOLID + "forClass"), pod.sym(AS_ACTOR))) continue;
+    const others = g.each(reg, instance, null).filter((i) => i.value !== actorUrl);
+    for (const st2 of others.length ? g.statementsMatching(reg, instance, actor) : g.statementsMatching(reg, null, null)) {
+      gone.push([st2.subject, st2.predicate, st2.object]);
+    }
+  }
+  if (!gone.length) return false;
+  const status2 = await pod.writeRdfChecked(indexUrl, g, { deletes: gone, mustDescribe: indexUrl });
+  if (status2 >= 300) throw new Error(`the type index at ${indexUrl} did not let the registration go (${status2})`);
+  return true;
+}
 async function createPublicIndex(pod, podBase) {
   const url = newIndexUrl(podBase);
   const doc = pod.sym(url);
@@ -45398,6 +45418,33 @@ var PodTransport = class {
     await this.writeAboutWebId(podBase, { inserts: missing, deletes: stale });
     return true;
   }
+  /**
+   * The account taken out of the WebID profile again, as linkAccountInProfile
+   * wrote it: the foaf:account link, what the profile says of the actor, and
+   * `outbox` when it is the one named. From every document of the profile that
+   * holds any of it, each write checked. Returns how many documents changed.
+   */
+  async unlinkAccountInProfile({ actorUrl, outbox = null }) {
+    const me = namedNode2(this.webId);
+    const actor = namedNode2(actorUrl);
+    let changed = 0;
+    for (const d of await this.profileDocs(podBaseOfWebId(this.webId))) {
+      if (!d.g) continue;
+      const gone = [
+        ...d.g.statementsMatching(me, FOAF("account"), actor),
+        ...d.g.statementsMatching(actor, RDF3("type"), FOAF("OnlineAccount")),
+        ...d.g.statementsMatching(actor, RDF3("type"), AS("Person")),
+        ...d.g.statementsMatching(actor, RDF3("type"), AS("Group")),
+        ...d.g.statementsMatching(actor, FOAF("accountName"), null),
+        ...outbox ? d.g.statementsMatching(me, AS("outbox"), namedNode2(outbox)) : []
+      ].map((st2) => [st2.subject, st2.predicate, st2.object]);
+      if (!gone.length) continue;
+      const status2 = await this.writeRdfChecked(d.url, d.g, { deletes: gone, mustDescribe: d.profile ? this.webId : null });
+      if (status2 >= 300) throw new Error(`not written: ${d.url} \u2192 ${status2}`);
+      changed++;
+    }
+    return changed;
+  }
   /**
    * An N3 Patch of exactly these statements, or false when the pod will not
    * take one and the caller should write the document instead.
@@ -45611,6 +45658,11 @@ async function recordPlace(pod, podBase, actorAtPod, { create = false } = {}) {
   }
   return await register(pod, index, actorAtPod) ? "registered" : "already";
 }
+async function forgetPlace(pod, podBase, actorAtPod) {
+  const index = await findPublicIndex(pod, podBase);
+  if (!index) return "no-index";
+  return await unregister(pod, index, actorAtPod) ? "removed" : "absent";
+}
 
 // lib/pod/containers.mjs
 var KEEP = { keep: true };
@@ -45821,9 +45873,13 @@ var PodStore = class {
   // Read these documents again, whatever is held: a kept copy caught them
   // mid-write, so the pod's copy is the one to hold. Throws when one cannot be
   // read, so the caller can fall back to a full load rather than act without it.
-  async refresh(names) {
+  // `ifChanged`: a document held here is asked for only if it changed since — a
+  // pod's listing does not change when a document in it is rewritten.
+  async refresh(names, { ifChanged = false } = {}) {
     for (const name of names) {
-      const r = await this.storage.read(name);
+      const etag = ifChanged && this.cache.has(name) ? this.etags.get(name) : null;
+      const r = await this.storage.read(name, etag ? { etag } : void 0);
+      if (r.notModified) continue;
       if (r.status === 404) {
         this.cache.delete(name);
         this.lastText.delete(name);
@@ -46441,6 +46497,9 @@ async function writeProfilePage(pod, urls, html) {
 function linkInWebIdProfile(pod, { actorUrl, accountName, kind = "person", outbox = null }) {
   return pod.linkAccountInProfile({ actorUrl, accountName, kind, outbox });
 }
+async function unlinkInWebIdProfile(pod, { actorUrl, outbox = null }) {
+  return pod.unlinkAccountInProfile({ actorUrl, outbox });
+}
 
 // lib/pod/inbox.mjs
 async function writeKeep(pod, urls) {
@@ -58595,7 +58654,7 @@ var Publisher = class {
       await writeWebfinger(
         this.remote,
         urls,
-        jrd({ handle: this.config.handle, host, actor: urls.actor, page: urls.profileHtml })
+        jrd({ handle: this.config.handle, host, actor: urls.actor, page: urls.profileHtml, avatar: this.config.icon || null })
       );
       await writeHostMeta(this.remote, urls, hostMeta(urls.base));
       const nodeinfoDocUrl = urls.home + "ap/nodeinfo-2.0";
@@ -58751,6 +58810,17 @@ var Publisher = class {
     await writeTombstone(this.remote, urls, tombstoneDoc(urls, deletedAt, this.config.kind));
     this.store.setConfig({ ...this.store.getConfig(), retiredAt: deletedAt });
     await this.store.flush();
+    if (!this.config.forum) {
+      await unlinkInWebIdProfile(this.remote, {
+        actorUrl: urls.actor,
+        outbox: this.clientOrigin ? `${this.clientOrigin}ap/outbox` : this.gatewayOutbox()
+      }).then((n) => {
+        if (n) this.log("the WebID profile no longer lists the actor");
+      }).catch((e) => this.log(`the WebID profile still lists the actor: ${e.message}`));
+      await forgetPlace(this.remote, urls.base, urls.home + "ap/actor").then((r) => {
+        if (r === "removed") this.log("the public type index no longer records the account");
+      }).catch((e) => this.log(`the type index still records the account: ${e.message}`));
+    }
     this.log(`retired: Delete sent to ${inboxes.length} inbox(es), actor replaced with a Tombstone`);
     return { inboxes: inboxes.length, deletedAt };
   }
@@ -73582,8 +73652,9 @@ var BrowserAgent = class _BrowserAgent {
   }
   // One call to the gateway's owner API, proved with the pod session. What
   // comes back on 200 or 410 is the account's standing there, kept for the
-  // manage page; anything else is logged and forgotten.
-  async tellGateway(what, body) {
+  // manage page; anything else is logged and forgotten. `standing: false` for
+  // a call whose answer says nothing about the account's standing.
+  async tellGateway(what, body, { standing = true } = {}) {
     if (!this.gatewayApi) return null;
     let res;
     try {
@@ -73598,12 +73669,16 @@ var BrowserAgent = class _BrowserAgent {
     }
     const json2 = await res.json().catch(() => ({}));
     const out = { status: res.status, ...json2 };
-    if (res.status === 200 || res.status === 410) this.gatewayStanding = out;
-    else this.log(`gateway ${what}: ${res.status} ${json2.error || ""}`);
+    if (res.status === 200 || res.status === 410) {
+      if (standing) this.gatewayStanding = out;
+    } else this.log(`gateway ${what}: ${res.status} ${json2.error || ""}`);
     return out;
   }
+  // The account's picture goes with it, for the address's WebFinger answer;
+  // said only once the account has been read, so "none" is never a guess.
   openAtGateway() {
-    return this.tellGateway("open", { handle: this.doorKey });
+    const config = this.store?.getConfig?.();
+    return this.tellGateway("open", { handle: this.doorKey, ...config ? { icon: config.icon || null } : {} });
   }
   pauseAtGateway(paused) {
     return this.tellGateway("pause", { handle: this.doorKey, paused: !!paused });
@@ -73612,6 +73687,24 @@ var BrowserAgent = class _BrowserAgent {
     return this.tellGateway("close", { handle: this.doorKey, confirm: true });
   }
   static OPEN_EVERY_MS = 60 * 6e4;
+  // A notification made here, from mail read while FediPod is open, goes to
+  // the phones the owner signed up, as one made while it is closed does
+  // (lib/gateway/held-mail.mjs: /api/push). Named a moment later, once written,
+  // so a burst is one call. One from another network is not pushed.
+  static PUSH_AFTER_MS = 2e3;
+  notePush(n) {
+    if (!this.gatewayApi || n?.bsky || n?.via) return;
+    if (!Object.keys(this.store.read("webpush.json", { subs: {} }).subs || {}).length) return;
+    (this._toPush ||= /* @__PURE__ */ new Set()).add(n.id);
+    this._pushTimer ||= setTimeout(async () => {
+      const ids = [...this._toPush];
+      this._toPush.clear();
+      this._pushTimer = null;
+      await this.store.flush?.().catch(() => {
+      });
+      await this.tellGateway("push", { handle: this.doorKey, ids }, { standing: false });
+    }, _BrowserAgent.PUSH_AFTER_MS);
+  }
   // The gateway acting for this account while the app is closed, or not. On:
   // the rules on the account's folders name the gateway's pod identity, then
   // the gateway is told. Off: the gateway is told first, so it stops, then the
@@ -73727,6 +73820,9 @@ var BrowserAgent = class _BrowserAgent {
           if (this.viewer) return;
         }
       }
+      this.store.onEvent = (type, n) => {
+        if (type === "notification") this.notePush(n);
+      };
       const now = Date.now();
       const hereDue = !warm || now - (warm.hereAt || 0) >= _BrowserAgent.HERE_EVERY_MS;
       const here = hereDue ? await this.hereAtGateway() : null;