completely overhaul landing + add knot landing

if this breaks im blowing myself up lol

caddy/Caddyfile

···
     format console
   }
 
-  @landing path / /css
+  rewrite / /pds
+  @landing path /pds /styles.css
   reverse_proxy @landing landing:8000
+  
+  # disable age assurance
+  handle /xrpc/app.bsky.ageassurance.getState {
+		header content-type "application/json"
+		header access-control-allow-headers "authorization,dpop,atproto-accept-labelers,atproto-proxy"
+		header access-control-allow-origin "*"
+		respond `{"state":{"lastInitiatedAt":"2025-07-14T14:22:43.912Z","status":"assured","access":"full"},"metadata":{"accountCreatedAt":"2022-11-17T00:35:16.391Z"}}` 200
+	}
 
   reverse_proxy {$PI_ADDRESS:pi}:8000 {
     transport http {
···
     output stdout
     format console
   }
+
+  rewrite / /knot
+  @landing path /knot /styles.css
+  reverse_proxy @landing landing:8000
 
   reverse_proxy {$PI_ADDRESS:pi}:5555
 }

compose.yaml

···
     build: ./landing
     environment:
       - PORT=8000
+      - PDS=http://100.84.64.24:8000
+      - KNOT_HOST=http://100.84.64.24:5555
+      # tangled uses a plain domain name for knots in lexicons. imo this is bad but it is what it is rn
+      # allows me to have a diff HOST to the public one which may improve speeds ig?
+      - KNOT_NAME=knot.vielle.dev
     restart: unless-stopped
 
   caddy:
···
       - caddy_config:/config
     environment:
       HOST: vielle.dev
+      DONG_HOST: dongs.zip
+      PDS_ADMIN_EMAIL: [e-mail]
+      PI_ADDRESS: "100.84.64.24"
+      PI_PORT_PDS: 8000
+      PI_PORT_KNOT: 5555
+      PI_PORT_PIPER: 8010
     depends_on:
       - prs
       - landing

landing/Dockerfile

···
 
 COPY ./ /app
 RUN deno install
-RUN deno bundle --unstable-raw-imports --output bundle.js /app/index.ts
+RUN deno bundle --unstable-raw-imports --output bundle.js /app/src/index.ts
 
-CMD deno --allow-net --unstable-temporal bundle.js
+CMD deno --allow-net --unstable-temporal --allow-env bundle.js

landing/deno.json

···
 {
+  "tasks": {
+    "dev": "deno run --allow-net --unstable-temporal --unstable-raw-imports --allow-env --watch ./src/index.ts"
+  },
   "imports": {
     "zod": "npm:zod@^4.1.13"
   }

landing/index.ts landing/src/pds/pds.ts

···
-import css from "./styles.css" with { type: "text" };
-import heading from "./heading.txt" with { type: "text" };
+import heading from "./pds-heading.txt" with { type: "text" };
 import {
   didDocSchema,
   getRecordSchema,
···
   profileSelfSchema,
   statusphereSchema,
   tealFmStatusSchema,
-} from "./schemas.ts";
+} from "../schemas.ts";
+import { stagger } from "../utils.ts";
 
-const PORT = Number(Deno.env.get("PORT"));
 const PDS = Deno.env.get("PDS") ?? "http://pi:8000";
+const PLC_DIRECTORY = Deno.env.get("PLC_DIRECTORY") ?? "https://plc.directory";
 
 async function renderUser(did: string): Promise<string> {
   const handle = fetch(
     did.startsWith("did:plc")
-      ? "https://plc.directory/" + did
+      ? `${PLC_DIRECTORY}/${did}`
       : `https://${did.replace("did:web:", "")}/.well-known/did.json`
   )
     .then((res) => res.json())
···
       (doc) =>
         doc.alsoKnownAs
           .filter((x) => x.startsWith("at://"))[0]
-          ?.replace("at://", "") ?? "invalid.handle"
-    );
+          ?.replace("at://", "") ?? "handle.invalid"
+    )
+    .catch(() => "handle.invalid");
 
-  const displayName = fetch(
+  const displayName: Promise<string | undefined> = fetch(
     `${PDS}/xrpc/com.atproto.repo.getRecord?repo=${did}&collection=app.bsky.actor.profile&rkey=self`
   )
     .then((res) => res.json())
     .then((data) => getRecordSchema(profileSelfSchema).safeParse(data).data)
-    .then((data) => (data ? data.value.displayName : undefined));
+    .then((data) => (data ? data.value.displayName : undefined))
+    .catch(() => undefined);
 
-  const statusphere = fetch(
+  const statusphere: Promise<string | undefined> = fetch(
     `${PDS}/xrpc/com.atproto.repo.listRecords?repo=${did}&collection=xyz.statusphere.status`
   )
     .then((res) => res.json())
     .then((data) => listRecordsSchema(statusphereSchema).safeParse(data).data)
     .then((data) =>
       data && data.records.length > 0 ? data.records[0].value.status : undefined
-    );
+    )
+    .catch(() => undefined);
 
   const nowPlaying = fetch(
     `${PDS}/xrpc/com.atproto.repo.getRecord?repo=${did}&collection=fm.teal.alpha.actor.status&rkey=self`
···
               ? `${data.value.item.artists.length - 1} more artist${data.value.item.artists.length > 1 ? "s" : ""}`
               : ""))
         : undefined
-    );
+    )
+    .catch(() => undefined);
 
   return (
     "- " +
···
   );
 }
 
-function landingPage(): Response {
+export default function (): Response {
   // get upstream pds status
   const status = fetch(`${PDS}/xrpc/_health`).then(
     async (res) => `${res.status} ${res.statusText} ${await res.text()}`
···
     },
   });
 
-  // buffer the output just to be easier to handle
-  const stagger = new TransformStream({
-    async transform(
-      chunk: string,
-      controller: TransformStreamDefaultController<string>
-    ) {
-      for (const part of chunk) {
-        controller.enqueue(part);
-        await new Promise((res) => setTimeout(res, 10));
-      }
-    },
-  });
-
   return new Response(
-    body.pipeThrough(stagger).pipeThrough(new TextEncoderStream()),
+    body.pipeThrough(stagger()).pipeThrough(new TextEncoderStream()),
     {
       headers: {
         "Content-Type": "text/text; charset=utf-8",
···
     }
   );
 }
-
-Deno.serve(
-  { port: !Number.isNaN(PORT) && PORT <= 65535 && PORT > 0 ? PORT : 8000 },
-  (req) => {
-    const path = new URL(req.url).pathname;
-    switch (path) {
-      case "/":
-        return landingPage();
-      case "/styles.css":
-        return new Response(css, {
-          headers: {
-            "Content-Type": "text/css; charset=utf-8",
-            "Access-Control-Allow-Origin": "*",
-          },
-        });
-      default:
-        return new Response(`404 Not Found: ${path} does not exist`, {
-          status: 400,
-          statusText: "Not Found",
-        });
-    }
-  }
-);

landing/schemas.ts landing/src/schemas.ts

···
   }),
 });
 
+export const tangledKnotOwnerSchema = z.object({
+  owner: z.string(),
+});
+
+export const tangledRepoSchema = z.object({
+  knot: z.string(),
+  name: z.string(),
+  description: z.string().optional(),
+  website: z.url().optional(),
+});
+
+export const slingshotMiniDocSchema = z.object({
+  pds: z.string(),
+  handle: z.string(),
+  did: z.string(),
+});
+
 export function getRecordSchema<T>(record: T) {
   return z.object({
     value: record,
···
         value: record,
       })
     ),
+    cursor: z.string().optional(),
   });
 }

landing/src/index.ts

···
+import css from "./styles.css" with { type: "text" };
+import pds from "./pds/pds.ts";
+import knot from "./knot/knot.ts";
+
+const PORT = Number(Deno.env.get("PORT"));
+
+Deno.serve(
+  { port: !Number.isNaN(PORT) && PORT <= 65535 && PORT > 0 ? PORT : 8000 },
+  (req) => {
+    const path = new URL(req.url).pathname;
+    console.log("PATH", path);
+    switch (path) {
+      case "/styles.css":
+        return new Response(css, {
+          headers: {
+            "Content-Type": "text/css; charset=utf-8",
+            "Access-Control-Allow-Origin": "*",
+          },
+        });
+
+      case "/pds":
+      case "/pds/":
+        return pds();
+
+      case "/knot":
+      case "/knot/":
+        return knot();
+    }
+
+    console.warn(`Request for ${path} returned 404`);
+    return new Response("404 Not Found", {
+      status: 404,
+      statusText: "Not Found",
+    });
+  }
+);

landing/src/knot/knot-heading.txt

···
+    __   ___  _  _  ___  __
+   |  \ /   \| \| |/ __|/__|
+ _ | - || - ||    || | |\__\
+|_||__/ \___/|_|\_|\___||__/
+
+
+Knot Source: https://tangled.org/tangled.org/core/tree/master/knotserver
+       Docs: https://tangled.org/tangled.org/core/tree/master/docs
+ .dong file: https://dongs.zip/
+     health: 

landing/src/knot/knot.ts

···
+import z from "zod";
+import heading from "./knot-heading.txt" with { type: "text" };
+import {
+  listRecordsSchema,
+  slingshotMiniDocSchema,
+  tangledKnotOwnerSchema,
+  tangledRepoSchema,
+} from "../schemas.ts";
+import { stagger } from "../utils.ts";
+
+const KNOT_HOST = Deno.env.get("KNOT_HOST") ?? "http://pi:5555";
+const KNOT_NAME = Deno.env.get("KNOT_NAME") ?? "knot.vielle.dev";
+const SLINGSHOT_INSTANCE =
+  Deno.env.get("SLINGSHOT_INSTANCE") ?? "https://slingshot.microcosm.blue";
+
+function getAllRecords<T>(
+  owner: string,
+  pds: string,
+  collection: string,
+  validator: z.ZodType,
+  cursor?: string
+): Promise<{ uri: string; cid: string; value: T }[]> {
+  return fetch(
+    `${pds}/xrpc/com.atproto.repo.listRecords?repo=${owner}&collection=${collection}&cursor=${cursor}`
+  )
+    .then((res) => res.json())
+
+    .then(
+      (res) =>
+        // check that it matches the schema and assume that the schema matches T
+        listRecordsSchema(validator).safeParse(res).data as {
+          records: {
+            uri: string;
+            cid: string;
+            value: T;
+          }[];
+          cursor?: string;
+        }
+    )
+    .then(async (res) => [
+      ...res.records,
+      ...(res.cursor
+        ? await getAllRecords<T>(owner, pds, collection, validator, res.cursor)
+        : []),
+    ]);
+}
+
+export default function (): Response {
+  // get upstream knot owner/status
+  const owner = fetch(`${KNOT_HOST}/xrpc/sh.tangled.owner`);
+  const status = owner.then(
+    async (res) => `${res.status} ${res.statusText} ${await res.clone().text()}`
+  );
+
+  const ownerDid: Promise<string | undefined> = owner
+    .then((res) => res.json())
+    .then((x) => tangledKnotOwnerSchema.safeParse(x).data?.owner)
+    .catch(() => undefined);
+
+  const ownerPds = ownerDid
+    .then((owner) =>
+      fetch(
+        `${SLINGSHOT_INSTANCE}/xrpc/com.bad-example.identity.resolveMiniDoc?identifier=${owner}`
+      )
+    )
+    .then((res) => res.json())
+    .then((x) => slingshotMiniDocSchema.safeParse(x).data?.pds);
+
+  const members = ownerPds
+    .then((pds) =>
+      ownerDid.then(async (owner) => [
+        owner,
+        ...(await getAllRecords<{ subject: string; domain: string }>(
+          owner,
+          pds,
+          "sh.tangled.knot.member",
+          z.object({
+            subject: z.string(),
+            domain: z.string(),
+          })
+        ).then((x) =>
+          x
+            .filter((x) => x.value.domain === KNOT_NAME)
+            .map((x) => x.value.subject)
+        )),
+      ])
+    )
+    .then((dids) =>
+      Promise.all(
+        dids.map((did) =>
+          fetch(
+            `${SLINGSHOT_INSTANCE}/xrpc/com.bad-example.identity.resolveMiniDoc?identifier=${did}`
+          )
+            .then((res) => res.json())
+            .then((res) => slingshotMiniDocSchema.safeParse(res).data)
+        )
+      )
+    );
+
+  const membersRepr = members.then(
+    (x) =>
+      "  - " +
+      x
+        .map((x) => (x.handle !== "handle.invalid" ? x.handle : x.did))
+        .join("\n  - ")
+  );
+
+  const repos = members.then((members) =>
+    Promise.all(
+      members.map((member) =>
+        getAllRecords<z.infer<typeof tangledRepoSchema>>(
+          member.did,
+          member.pds,
+          "sh.tangled.repo",
+          tangledRepoSchema
+        ).then((x) =>
+          x.map((x) => ({
+            ...x.value,
+            user:
+              member.handle !== "handle.invalid" ? member.handle : member.did,
+          }))
+        )
+      )
+    ).then((x) => x.flat().filter((x) => x.knot === KNOT_NAME))
+  );
+
+  const reposRepr = repos.then(
+    (x) =>
+      "  - " +
+      x
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+        .map(
+          (x) =>
+            `${x.user}/${x.name}${x.description ? `\n    ${x.description}` : ""}${x.website ? `\n    ${x.website}` : ""}`
+        )
+        .join("\n  - ") +
+      "\n"
+  );
+
+  const body = new ReadableStream({
+    async start(controller) {
+      controller.enqueue(heading);
+      controller.enqueue(await status);
+      controller.enqueue("\n\nMembers:\n");
+      controller.enqueue(await membersRepr);
+      controller.enqueue("\n\nRepos:\n");
+      controller.enqueue(await reposRepr);
+      controller.close();
+    },
+  });
+
+  return new Response(
+    body.pipeThrough(stagger()).pipeThrough(new TextEncoderStream()),
+    {
+      headers: {
+        "Content-Type": "text/text; charset=utf-8",
+        "Access-Control-Allow-Origin": "*",
+        Link: "</styles.css>; rel=stylesheet",
+      },
+    }
+  );
+}

landing/src/utils.ts

···
+/**
+ * Delays the output of each character in the input stream by 10ms
+ * @returns TransformStream
+ */
+export const stagger = () =>
+  new TransformStream({
+    async transform(
+      chunk: string,
+      controller: TransformStreamDefaultController<string>
+    ) {
+      for (const part of chunk) {
+        controller.enqueue(part);
+        await new Promise((res) => setTimeout(res, 10));
+      }
+    },
+  });