site: apps question, supporter share card and an app lookup page

apps/site/scripts/count-requested-apps.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// Copyright The PDP-Connect Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Counts how many signatories named each app they would like to see join PDPP.
+// Reads a local checkout of the private register and prints, to stdout:
+//   {"apps": [{app, count}], "unreviewedAnswers": N}
+// `apps` holds only canonical names: the reviewed names below plus the targets
+// of the alias map. Anything else a signer typed is free
+// text and can be personal data (an email, a name, a phone number), so it is
+// counted but never printed. The stdout output is safe to share with a company.
+//
+// `--review` additionally prints the unreviewed raw values and their counts to
+// STDERR, so a maintainer can extend the alias map. That output is private.
+
+import { readSignatories } from "./publish-supporters.mjs";
+
+const WHITESPACE = /\s+/g;
+
+// App names a maintainer has reviewed and may print. The form is free text;
+// extend this list (and ALIASES) from what `--review` shows.
+const REVIEWED_APP_NAMES = [
+  "Amazon",
+  "Apple Health",
+  "ChatGPT",
+  "Clue",
+  "Fitbit",
+  "Flo",
+  "Garmin",
+  "Google",
+  "Instagram",
+  "LinkedIn",
+  "Netflix",
+  "Oura",
+  "Reddit",
+  "Spotify",
+  "Strava",
+  "TikTok",
+  "Uber",
+  "WhatsApp",
+  "X",
+  "YouTube",
+];
+
+// Lower-cased, space-collapsed spelling -> the name to count it under.
+const ALIASES = new Map([
+  ["insta", "Instagram"],
+  ["ig", "Instagram"],
+  ["chat gpt", "ChatGPT"],
+  ["chatgpt", "ChatGPT"],
+  ["openai", "ChatGPT"],
+  ["open ai", "ChatGPT"],
+  ["apple health kit", "Apple Health"],
+  ["healthkit", "Apple Health"],
+  ["twitter", "X"],
+  ["yt", "YouTube"],
+  ["you tube", "YouTube"],
+  ["whats app", "WhatsApp"],
+  ["tik tok", "TikTok"],
+]);
+
+// Folded spelling -> canonical name, for every name that may be printed.
+const CANONICAL = new Map([...REVIEWED_APP_NAMES, ...ALIASES.values()].map((name) => [foldName(name), name]));
+
+function foldName(name) {
+  return String(name).trim().replace(WHITESPACE, " ").toLowerCase();
+}
+
+/** The distinct folded spellings one record asks for, with their trimmed raw form. */
+function namesInRecord(record) {
+  const names = new Map();
+  for (const raw of Array.isArray(record?.requestedApps) ? record.requestedApps : []) {
+    const key = typeof raw === "string" ? foldName(raw) : "";
+    if (key && !names.has(key)) {
+      names.set(key, raw.trim().replace(WHITESPACE, " "));
+    }
+  }
+  return names;
+}
+
+function mostCommonSpelling(spellings) {
+  // A tie goes to the first by code point, which puts a capitalised spelling
+  // ahead of a lower-case one.
+  return [...spellings.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1))[0][0];
+}
+
+/**
+ * Counts requested apps across records. One signatory counts once per app,
+ * however they spelled it.
+ *
+ * Returns:
+ * - apps: [{app, count}] for canonical names only, count descending. Safe to share.
+ * - unreviewedAnswers: how many answers matched no canonical name. A count only. Safe to share.
+ * - unreviewed: [{value, count}] the raw unmatched values. PRIVATE: may be personal data.
+ */
+export function countRequestedApps(records) {
+  const canonicalCounts = new Map();
+  const unreviewedGroups = new Map();
+  for (const record of records) {
+    const seenCanonical = new Set();
+    for (const [key, spelling] of namesInRecord(record)) {
+      const canonical = ALIASES.get(key) ?? CANONICAL.get(key) ?? null;
+      if (canonical) {
+        seenCanonical.add(canonical);
+        continue;
+      }
+      const group = unreviewedGroups.get(key) ?? { count: 0, spellings: new Map() };
+      group.count += 1;
+      group.spellings.set(spelling, (group.spellings.get(spelling) ?? 0) + 1);
+      unreviewedGroups.set(key, group);
+    }
+    for (const canonical of seenCanonical) {
+      canonicalCounts.set(canonical, (canonicalCounts.get(canonical) ?? 0) + 1);
+    }
+  }
+  const apps = [...canonicalCounts.entries()]
+    .map(([app, count]) => ({ app, count }))
+    .sort((a, b) => b.count - a.count || a.app.localeCompare(b.app));
+  const unreviewed = [...unreviewedGroups.values()]
+    .map((group) => ({ value: mostCommonSpelling(group.spellings), count: group.count }))
+    .sort((a, b) => b.count - a.count || a.value.localeCompare(b.value));
+  return {
+    apps,
+    unreviewed,
+    unreviewedAnswers: unreviewed.reduce((total, entry) => total + entry.count, 0),
+  };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const review = args.includes("--review");
+  const [sourceDirectory] = args.filter((arg) => arg !== "--review");
+  if (!sourceDirectory) {
+    console.error("Usage: count-requested-apps.mjs [--review] <private-register-directory>");
+    process.exitCode = 1;
+    return;
+  }
+  const { apps, unreviewed, unreviewedAnswers } = countRequestedApps(await readSignatories(sourceDirectory));
+  console.log(JSON.stringify({ apps, unreviewedAnswers }, null, 2));
+  if (review) {
+    console.error(
+      "PRIVATE: unreviewed values typed by signatories. They may be personal data. Do not share, paste or commit."
+    );
+    console.error(JSON.stringify(unreviewed, null, 2));
+  }
+}
+
+if (import.meta.main) {
+  main().catch((error) => {
+    // A JSON SyntaxError message quotes a snippet of the file, which is
+    // personal data, so it is replaced rather than passed through.
+    console.error(
+      error instanceof SyntaxError ? "A signatory file is not valid JSON." : (error?.message ?? "count failed")
+    );
+    process.exitCode = 1;
+  });
+}

apps/site/scripts/count-requested-apps.test.ts

@@ -0,0 +1,129 @@
+// Copyright The PDP-Connect Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, test } from "node:test";
+import { promisify } from "node:util";
+import { countRequestedApps } from "./count-requested-apps.mjs";
+
+const USAGE = /Usage:/;
+const PRIVATE_LABEL = /PRIVATE.*Do not share/;
+const run = promisify(execFile);
+const SCRIPT = path.join(import.meta.dirname, "count-requested-apps.mjs");
+const temporaryDirectories: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(
+    temporaryDirectories.splice(0).map(async (directory) => await rm(directory, { force: true, recursive: true }))
+  );
+});
+
+const EMAIL_VALUE = "alice@example.test";
+const NAME_VALUE = "Alice Fakename";
+const PHONE_VALUE = "+1 555 010 0199";
+const PERSONAL_VALUES = [EMAIL_VALUE, NAME_VALUE, PHONE_VALUE];
+
+test("count folds case, spacing and aliases, and sorts by count", () => {
+  const { apps } = countRequestedApps([
+    { requestedApps: ["Spotify", "insta"] },
+    { requestedApps: ["  spotify ", "Chat  GPT"] },
+    { requestedApps: ["OpenAI", "Instagram", "Strava"] },
+    { requestedApps: [] },
+    { id: "legacy-record-without-the-field" },
+  ]);
+  assert.deepEqual(apps, [
+    { app: "ChatGPT", count: 2 },
+    { app: "Instagram", count: 2 },
+    { app: "Spotify", count: 2 },
+    { app: "Strava", count: 1 },
+  ]);
+});
+
+test("one signatory counts once per app even when they spell it two ways", () => {
+  assert.deepEqual(countRequestedApps([{ requestedApps: ["Insta", "Instagram", "instagram"] }]).apps, [
+    { app: "Instagram", count: 1 },
+  ]);
+});
+
+test("an app outside the reviewed names and alias map is unreviewed, never in apps", () => {
+  const result = countRequestedApps([
+    { requestedApps: ["oura", "Obscure App"] },
+    { requestedApps: ["Oura", "obscure  app"] },
+    { requestedApps: ["Obscure App"] },
+  ]);
+  assert.deepEqual(result.apps, [{ app: "Oura", count: 2 }]);
+  assert.equal(result.unreviewedAnswers, 3);
+  assert.deepEqual(result.unreviewed, [{ value: "Obscure App", count: 3 }]);
+});
+
+async function writeRegister(records: Array<{ id: string; requestedApps: string[] }>): Promise<string> {
+  const directory = await mkdtemp(path.join(tmpdir(), "pdpp-app-counts-"));
+  temporaryDirectories.push(directory);
+  const year = path.join(directory, "signatories", "2026");
+  await mkdir(year, { recursive: true });
+  await Promise.all(
+    records.map(
+      async (record) =>
+        await writeFile(
+          path.join(year, `${record.id}.json`),
+          JSON.stringify({
+            displayName: `Fake Person ${record.id}`,
+            email: `${record.id}@example.test`,
+            ...record,
+          })
+        )
+    )
+  );
+  return directory;
+}
+
+test("default output holds canonical names and an unreviewed total, never free text", async () => {
+  const directory = await writeRegister([
+    { id: "first-fake-id", requestedApps: ["Spotify", "Strava", EMAIL_VALUE] },
+    { id: "second-fake-id", requestedApps: ["spotify", NAME_VALUE] },
+    { id: "third-fake-id", requestedApps: [PHONE_VALUE] },
+  ]);
+
+  const { stdout, stderr } = await run(process.execPath, [SCRIPT, directory]);
+  assert.deepEqual(JSON.parse(stdout), {
+    apps: [
+      { app: "Spotify", count: 2 },
+      { app: "Strava", count: 1 },
+    ],
+    unreviewedAnswers: 3,
+  });
+  assert.equal(stderr, "");
+  for (const private_ of [...PERSONAL_VALUES, "Fake Person", "example.test", "fake-id", "555"]) {
+    assert.equal(stdout.includes(private_), false, `${private_} must not appear in the output`);
+  }
+});
+
+test("--review shows unreviewed values on stderr only, labelled private", async () => {
+  const directory = await writeRegister([
+    { id: "first-fake-id", requestedApps: ["Spotify", ...PERSONAL_VALUES] },
+    { id: "second-fake-id", requestedApps: [EMAIL_VALUE] },
+  ]);
+
+  const { stdout, stderr } = await run(process.execPath, [SCRIPT, "--review", directory]);
+  assert.deepEqual(JSON.parse(stdout), { apps: [{ app: "Spotify", count: 1 }], unreviewedAnswers: 4 });
+  for (const private_ of PERSONAL_VALUES) {
+    assert.equal(stdout.includes(private_), false, `${private_} must not appear on stdout`);
+    assert.equal(stderr.includes(private_), true, `${private_} should be listed for review on stderr`);
+  }
+  assert.match(stderr, PRIVATE_LABEL);
+  for (const leaked of ["Fake Person", "fake-id"]) {
+    assert.equal(stderr.includes(leaked), false, `${leaked} is not a requested app and must not appear`);
+  }
+});
+
+test("the command exits non-zero with a usage line when given no directory", async () => {
+  await assert.rejects(run(process.execPath, [SCRIPT]), (error: { code?: number; stderr?: string }) => {
+    assert.equal(error.code, 1);
+    assert.match(error.stderr ?? "", USAGE);
+    return true;
+  });
+});

apps/site/scripts/publish-supporters.test.ts

@@ -38,6 +38,7 @@ test("publish supporters writes only consented public fields", async () => {
       privateMetadata: { identityProviderToken: "nested-private-token" },
       principlesVersion: "v1.0",
       publicName: "Public P.",
+      requestedApps: ["Fake Requested App"],
       signatoryName: "Private Signatory",
       signatoryRole: "Private Role",
       type: "Individual",
@@ -76,6 +77,8 @@ test("publish supporters writes only consented public fields", async () => {
     "Private Signatory",
     "Private Role",
     "unlisted@example.test",
+    "Fake Requested App",
+    "requestedApps",
   ]) {
     assert.equal(output.includes(privateValue), false, `${privateValue} must not reach the public register`);
   }

apps/site/scripts/seo-metadata.test.ts

@@ -88,6 +88,7 @@ test("sitemap includes the front door, nav destinations, and every real doc page
   assert.ok(urls.includes(SITE_ORIGIN), "front door must be in the sitemap");
   assert.ok(urls.includes(`${SITE_ORIGIN}/self-host`));
   assert.ok(urls.includes(`${SITE_ORIGIN}/participate`));
+  assert.ok(urls.includes(`${SITE_ORIGIN}/apps`));
   assert.ok(urls.includes(`${SITE_ORIGIN}/specification`), "the docs index itself must be listed exactly once");
   assert.ok(urls.includes(`${SITE_ORIGIN}/specification/spec-core`));
   // A normative companion specification: unlisting the maintainer documents

apps/site/scripts/sync-connector-catalog.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// Copyright The PDP-Connect Contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Refreshes src/data/connector-catalog.json, the fallback copy of the catalogue for /apps.
+//
+// The page loads the catalogue live and refreshes it hourly. This file is
+// the copy it falls back to when that load fails, so refresh it now and then.
+// The loading code, and what it does and does not verify, is in
+// src/lib/connector-catalog.mjs.
+//
+// Run: node scripts/sync-connector-catalog.mjs [--out <path>]
+
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConnectorSnapshot } from "../src/lib/connector-catalog.mjs";
+
+// Measured against the repo formatter: it keeps a JSON array on one line up to this width.
+const LINE_WIDTH = 80;
+const TRAILING_COMMA = /,$/;
+const STRING_ARRAY = /^( *)("[^"]+": )\[\n((?: +"(?:[^"\\]|\\.)*",?\n)+) *\]/gm;
+
+/**
+ * JSON.stringify output, with each short array of strings on one line. The
+ * committed file is checked by the repo formatter, which lays arrays out the
+ * same way, so a fresh sync leaves no formatting diff.
+ */
+export function formatSnapshot(snapshot) {
+  const text = JSON.stringify(snapshot, null, 2).replace(STRING_ARRAY, (whole, indent, key, body) => {
+    const items = body
+      .trim()
+      .split("\n")
+      .map((item) => item.trim().replace(TRAILING_COMMA, ""));
+    const line = `${indent}${key}[${items.join(", ")}]`;
+    return line.length <= LINE_WIDTH ? line : whole;
+  });
+  return `${text}\n`;
+}
+
+const DEFAULT_OUTPUT = fileURLToPath(new URL("../src/data/connector-catalog.json", import.meta.url));
+
+export async function syncConnectorCatalog(outputPath = DEFAULT_OUTPUT) {
+  const snapshot = await loadConnectorSnapshot();
+  await mkdir(path.dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, formatSnapshot(snapshot));
+  return snapshot;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const outIndex = process.argv.indexOf("--out");
+  const outputPath = outIndex === -1 ? DEFAULT_OUTPUT : path.resolve(process.argv[outIndex + 1]);
+  const snapshot = await syncConnectorCatalog(outputPath);
+  const withLabels = snapshot.connectors.filter((connector) => connector.labels.length > 0).length;
+  console.log(
+    `Wrote ${snapshot.connectors.length} connectors (${withLabels} with labels) to ${outputPath}\n` +
+      `manifest ${snapshot.manifest_digest}\nlayer    ${snapshot.layer_digest}\ncommit   ${snapshot.source_commit}`
+  );
+}