added more notifications

flake.nix

···
         pname = "atproto-basic-notifications";
         version = "0.1.0";
         src = ./.;
-        npmDepsHash = "sha256-gGiNDtxgof7L5y3bH7VWukezEMZbzYkSDdovUwaKQGA=";
+        npmDepsHash = "sha256-TWw+/vTB3Ai4wTakUvYEI8/NYPdgudAkxZteR/55tcw=";
         meta.mainProgram = "atproto-basic-notifications";
       };
   in {

index.ts

···
 import {
   Client,
-  CredentialManager,
-  ok,
+  ClientResponse,
+  FailedClientResponse,
   simpleFetchHandler,
 } from "@atcute/client";
 import { JetstreamSubscription } from "@atcute/jetstream";
-import { Did, is, RecordKey } from "@atcute/lexicons";
+import {
+  CanonicalResourceUri,
+  Did,
+  parseCanonicalResourceUri,
+  ParsedCanonicalResourceUri,
+  RecordKey,
+} from "@atcute/lexicons";
 
 import { AppBskyFeedPost } from "@atcute/bluesky";
 import {
   ProfileViewDetailed,
   VerificationView,
 } from "@atcute/bluesky/types/app/actor/defs";
+import {
+  ShTangledFeedStar,
+  ShTangledRepoIssue,
+  ShTangledRepoIssueComment,
+} from "@atcute/tangled";
+import {
+  CompositeDidDocumentResolver,
+  PlcDidDocumentResolver,
+  WebDidDocumentResolver,
+} from "@atcute/identity-resolver";
+import { AtprotoDid } from "@atcute/lexicons/syntax";
+import { XRPCProcedures, XRPCQueries } from "@atcute/lexicons/ambient";
 
-const TARGET_DID = process.env.TARGET_DID || "did:plc:3c6vkaq7xf5kz3va3muptjh5";
+const TARGET_DID = (process.env.TARGET_DID ||
+  "did:plc:3c6vkaq7xf5kz3va3muptjh5") as Did;
 
 const JETSTREAM_URL =
   process.env.JETSTREAM_URL ||
···
 const PDSLS_URL = process.env.PDSLS_URL || "https://pdsls.dev";
 const TANGLED_URL = process.env.TANGLED_URL || "https://tangled.sh";
 
-const CACHE_LIFETIME_MS = 30 * 60 * 1000; // 30 minutes in milliseconds
-
-const client = new Client({
-  handler: simpleFetchHandler({ service: "https://public.api.bsky.app" }),
-});
+const CACHE_LIFETIME = 60 * 60 * 1000; // 60 minutes in milliseconds
 
-const profileCache = new Map<
-  Did,
-  { profile: ProfileViewDetailed; timestamp: number }
+const cache = new Map<
+  string,
+  { value: any; timestamp: number; lifetime: number }
 >();
 
-const getProfile = async (did: Did) => {
-  const cached = profileCache.get(did);
+const getWithCache = async <T>(
+  key: string,
+  fetcher: () => Promise<T>,
+  lifetime?: number,
+): Promise<T> => {
+  const cached = cache.get(key);
   const now = Date.now();
 
-  if (cached && now - cached.timestamp < CACHE_LIFETIME_MS) {
-    return cached.profile;
+  if (cached && now - cached.timestamp < cached.lifetime) {
+    return cached.value as T;
   }
 
-  const profile = (
-    await client.get("app.bsky.actor.getProfile", {
-      params: {
-        actor: did,
-      },
-    })
-  ).data;
+  const value = await fetcher();
+  cache.set(key, {
+    value,
+    timestamp: now,
+    lifetime: lifetime ?? CACHE_LIFETIME,
+  });
+  return value;
+};
 
-  if ("error" in profile)
-    return {
-      $type: "app.bsky.actor.defs#profileViewDetailed",
-      did: did,
-      handle: "handle.invalid",
-      displayName: "silent error!",
-    } as ProfileViewDetailed;
+const docResolver = new CompositeDidDocumentResolver({
+  methods: {
+    plc: new PlcDidDocumentResolver(),
+    web: new WebDidDocumentResolver(),
+  },
+});
 
-  profileCache.set(did, { profile, timestamp: now });
-  return profile;
+const bskyClient = new Client({
+  handler: simpleFetchHandler({ service: "https://public.api.bsky.app" }),
+});
+const clientGetRecord = async (
+  uri: ParsedCanonicalResourceUri,
+): Promise<
+  ClientResponse<
+    XRPCQueries["com.atproto.repo.getRecord"],
+    XRPCQueries["com.atproto.repo.getRecord"]
+  >
+> => {
+  return getWithCache(
+    uri.collection + uri.repo + uri.rkey,
+    async () => {
+      try {
+        const doc = await docResolver.resolve(uri.repo as AtprotoDid);
+        const atprotoPdsService = doc.service?.find(
+          (s) =>
+            s.id === "#atproto_pds" && s.type === "AtprotoPersonalDataServer",
+        );
+        const pdsServiceEndpoint = atprotoPdsService?.serviceEndpoint;
+        if (!pdsServiceEndpoint || typeof pdsServiceEndpoint !== "string") {
+          throw new Error("No PDS service endpoint found");
+        }
+        const client = new Client({
+          handler: simpleFetchHandler({ service: pdsServiceEndpoint }),
+        });
+        return await client.get("com.atproto.repo.getRecord", { params: uri });
+      } catch (err) {
+        return { ok: false, data: err } as FailedClientResponse;
+      }
+    },
+    CACHE_LIFETIME * 24,
+  );
 };
 
-const sendNotification = async (
-  title: string,
-  icon: `${string}:${string}` | undefined,
-  message: string,
-  url: string,
-  priority: number = 3,
-) => {
-  await fetch(NTFY_URL, {
+const getId = (profile: ProfileViewDetailed) => {
+  return profile.handle !== "handle.invalid" ? profile.handle : profile.did;
+};
+
+const getProfile = async (did: Did): Promise<ProfileViewDetailed> => {
+  return getWithCache(
+    "bskyProfile_" + did,
+    async () => {
+      const profile = (
+        await bskyClient.get("app.bsky.actor.getProfile", {
+          params: {
+            actor: did,
+          },
+        })
+      ).data;
+
+      if ("error" in profile)
+        return {
+          $type: "app.bsky.actor.defs#profileViewDetailed",
+          did: did,
+          handle: "handle.invalid",
+          displayName: "silent error!",
+        } as ProfileViewDetailed;
+
+      return profile;
+    },
+    CACHE_LIFETIME * 4,
+  );
+};
+
+const errorRepo = {
+  name: "Repository not found",
+};
+
+const getTangledRepo = async (
+  uri: CanonicalResourceUri,
+): Promise<{ name: string }> => {
+  const res = parseCanonicalResourceUri(uri);
+  if (!res.ok) return errorRepo;
+
+  return getWithCache(uri, async () => {
+    const repo = (await clientGetRecord(res.value)).data;
+
+    if ("error" in repo || !("name" in repo.value)) return errorRepo;
+
+    return repo.value as { name: string };
+  });
+};
+
+const errorIssue = {
+  title: "Repository not found",
+  repo: "at://did:web:fake/nope.nada/nada" as CanonicalResourceUri,
+};
+
+const getTangledIssue = async (
+  uri: CanonicalResourceUri,
+): Promise<{ title: string; repo: CanonicalResourceUri }> => {
+  const res = parseCanonicalResourceUri(uri);
+  if (!res.ok) return errorIssue;
+
+  return getWithCache(uri, async () => {
+    const repo = (await clientGetRecord(res.value)).data;
+
+    if ("error" in repo || !("title" in repo.value)) return errorIssue;
+
+    return repo.value as {
+      title: string;
+      repo: CanonicalResourceUri;
+    };
+  });
+};
+
+const sendNotification = async (args: {
+  title?: string;
+  icon?: `${string}:${string}` | undefined;
+  message?: string;
+  url?: string;
+  priority?: number;
+  picture?: string | undefined;
+}) => {
+  const res = await fetch(NTFY_URL, {
     method: "POST",
     headers: {
-      Title: title,
-      Icon: icon ?? "",
-      Priority: priority.toString(),
-      Click: url,
+      Title: args.title ?? "",
+      Icon: args.icon ?? "",
+      Priority: args.priority?.toString() ?? "3",
+      Click: args.url ?? "",
+      Attach: args.picture ?? "",
     },
-    body: message,
+    body: args.message ?? null,
   });
+
+  if ("error" in res) {
+    console.error(JSON.stringify(res));
+  }
 };
 
 const wantedCollections = [
···
   ) => void;
 } = {
   "app.bsky.feed.post": async (did, rkey, record: AppBskyFeedPost.Main) => {
+    const embedTable = {
+      "app.bsky.embed.external": "External Link",
+      "app.bsky.embed.images": "Image",
+      "app.bsky.embed.record": "Record",
+      "app.bsky.embed.recordWithMedia": "Record with Media",
+      "app.bsky.embed.video": "Video",
+    };
+
     const profile = await getProfile(did);
 
     const typeOfPost =
···
         : "mentioned you";
 
     const post = record as AppBskyFeedPost.Main;
-    sendNotification(
-      "Bluesky",
-      profile.avatar,
-      `${profile.handle} ${typeOfPost}: ${post.text}`,
-      `${BSKY_URL}/profile/${profile.did}/post/${rkey}`,
-    );
+    sendNotification({
+      title: "Bluesky",
+      icon: profile.avatar,
+      message:
+        `${getId(profile)} ${typeOfPost}: ${post.text}` +
+        (post.embed
+          ? (post.text.length > 0 ? " " : "") +
+            `[${embedTable[post.embed.$type]}]`
+          : ""),
+      url: `${BSKY_URL}/profile/${profile.did}/post/${rkey}`,
+    });
   },
   "app.bsky.feed.follow": async (did, rkey, record) => {
     const profile = await getProfile(did);
 
-    sendNotification(
-      "Bluesky",
-      profile.avatar,
-      `${profile.handle} followed you`,
-      `${BSKY_URL}/profile/${profile.did}`,
-      2,
-    );
+    sendNotification({
+      title: "Bluesky",
+      icon: profile.avatar,
+      message: `${getId(profile)} followed you`,
+      url: `${BSKY_URL}/profile/${profile.did}`,
+      priority: 2,
+    });
   },
   "app.bsky.graph.verification": async (
     did,
···
   ) => {
     const profile = await getProfile(did);
 
-    sendNotification(
-      "Bluesky",
-      profile.avatar,
-      `${profile.handle} verified you`,
-      `${PDSLS_URL}/${record.uri}`,
-      2,
-    );
+    sendNotification({
+      title: "Bluesky",
+      icon: profile.avatar,
+      message: `${getId(profile)} verified you`,
+      url: `${PDSLS_URL}/${record.uri}`,
+      priority: 2,
+    });
   },
   "sh.tangled.graph.follow": async (did, rkey, record) => {
     const profile = await getProfile(did);
 
-    sendNotification(
-      "Tangled",
-      profile.avatar,
-      `${profile.handle} followed you`,
-      `${TANGLED_URL}/@${profile.did}`,
-      2,
-    );
+    sendNotification({
+      title: "Tangled",
+      icon: profile.avatar,
+      message: `${getId(profile)} followed you`,
+      url: `${TANGLED_URL}/@${profile.did}`,
+    });
+  },
+  "sh.tangled.feed.star": async (did, rkey, record: ShTangledFeedStar.Main) => {
+    const profile = await getProfile(did);
+    const repo = await getTangledRepo(record.subject as CanonicalResourceUri);
+
+    sendNotification({
+      title: "Tangled",
+      icon: profile.avatar,
+      message: `${getId(profile)} starred ${repo.name}`,
+      url: `${TANGLED_URL}/@${profile.did}`,
+      priority: 2,
+    });
+  },
+  "sh.tangled.repo.issue": async (
+    did,
+    rkey,
+    record: ShTangledRepoIssue.Main,
+  ) => {
+    const profile = await getProfile(did);
+    const repo = await getTangledRepo(record.repo as CanonicalResourceUri);
+
+    sendNotification({
+      title: "Tangled",
+      icon: profile.avatar,
+      message: `${getId(profile)} opened an issue, "${record.title}", on ${repo.name}: ${record.body}`,
+      url: `${TANGLED_URL}`,
+    });
+  },
+  "sh.tangled.repo.issue.comment": async (
+    did,
+    rkey,
+    record: ShTangledRepoIssueComment.Main,
+  ) => {
+    const profile = await getProfile(did);
+    const issue = await getTangledIssue(record.issue as CanonicalResourceUri);
+    const repo = await getTangledRepo(issue.repo as CanonicalResourceUri);
+
+    sendNotification({
+      title: "Tangled",
+      icon: profile.avatar,
+      message: `${getId(profile)} commented on issue "${issue.title}", on ${repo.name}: ${record.body}`,
+      url: `${TANGLED_URL}/@${profile.did}`,
+    });
   },
 };
 

package-lock.json

···
 {
   "name": "atproto-basic-notifications",
+  "version": "0.1.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
+      "name": "atproto-basic-notifications",
+      "version": "0.1.0",
+      "license": "MIT",
       "dependencies": {
+        "@atcute/atproto": "^3.1.3",
         "@atcute/bluesky": "^3.2.2",
         "@atcute/client": "^4.0.3",
+        "@atcute/identity-resolver": "^1.1.3",
         "@atcute/jetstream": "^1.1.0",
-        "@atcute/lexicons": "^1.1.1"
+        "@atcute/lexicons": "^1.1.1",
+        "@atcute/tangled": "^1.0.5"
       },
       "bin": {
         "atproto-basic-notifications": "dist/index.js"
···
         "@badrap/valita": "^0.4.5"
       }
     },
+    "node_modules/@atcute/identity-resolver": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@atcute/identity-resolver/-/identity-resolver-1.1.3.tgz",
+      "integrity": "sha512-KZgGgg99CWaV7Df3+h3X/WMrDzTPQVfsaoIVbTNLx2B56BvCL2EmaxPSVw/7BFUJMZHlVU4rtoEB4lyvNyMswA==",
+      "license": "MIT",
+      "dependencies": {
+        "@atcute/lexicons": "^1.0.4",
+        "@atcute/util-fetch": "^1.0.1",
+        "@badrap/valita": "^0.4.4"
+      },
+      "peerDependencies": {
+        "@atcute/identity": "^1.0.0"
+      }
+    },
     "node_modules/@atcute/jetstream": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@atcute/jetstream/-/jetstream-1.1.0.tgz",
···
       "license": "0BSD",
       "dependencies": {
         "esm-env": "^1.2.2"
+      }
+    },
+    "node_modules/@atcute/tangled": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@atcute/tangled/-/tangled-1.0.5.tgz",
+      "integrity": "sha512-aitbeyrFQ0uWLMI/W6uWsQnDaHVCqrRo8hIEoDWd0sAjFmLAMsev6SuRUICDbRHBmj76vK+ZQxGGOf5QfDBa3g==",
+      "license": "0BSD",
+      "dependencies": {
+        "@atcute/atproto": "^3.1.3",
+        "@atcute/lexicons": "^1.1.1"
+      }
+    },
+    "node_modules/@atcute/util-fetch": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@atcute/util-fetch/-/util-fetch-1.0.1.tgz",
+      "integrity": "sha512-Clc0E/5ufyGBVfYBUwWNlHONlZCoblSr4Ho50l1LhmRPGB1Wu/AQ9Sz+rsBg7fdaW/auve8ulmwhRhnX2cGRow==",
+      "license": "MIT",
+      "dependencies": {
+        "@badrap/valita": "^0.4.2"
       }
     },
     "node_modules/@badrap/valita": {

package.json

···
   "scripts": {
     "build": "npm install && tsc",
     "start": "node dist/index.js",
-    "dev": "tsc --watch"
+    "dev": "tsc && npm run start"
   },
   "bin": {
     "atproto-basic-notifications": "dist/index.js"
···
     "typescript": "^5.5.3"
   },
   "dependencies": {
+    "@atcute/atproto": "^3.1.3",
     "@atcute/bluesky": "^3.2.2",
     "@atcute/client": "^4.0.3",
+    "@atcute/identity-resolver": "^1.1.3",
     "@atcute/jetstream": "^1.1.0",
-    "@atcute/lexicons": "^1.1.1"
+    "@atcute/lexicons": "^1.1.1",
+    "@atcute/tangled": "^1.0.5"
   }
 }

tsconfig.json

···
     "module": "NodeNext",
     "moduleResolution": "nodenext",
     "target": "esnext",
-    "types": ["@types/node", "@atcute/lexicons"],
+    "types": [
+      "@types/node",
+      "@atcute/lexicons",
+      "@atcute/atproto",
+      "@atcute/bluesky",
+      "@atcute/tangled",
+      "@atcute/identity-resolver"
+    ],
     // For nodejs:
     // "lib": ["esnext"],
     // "types": ["node"],