@decentnetwork/beagle-service 0.0.0-stage → 0.1.0

package/dist/users.js

@@ -0,0 +1,379 @@
+import { addressOf, Hub, isUserid, KeyedLock, msgOf } from "./util.js";
+export const DEFAULT_PROFILE_GATEWAY = "https://ens-gateway.beaglechat.workers.dev";
+const DAY_MS = 86_400_000;
+const TOUCH_EVERY_MS = 60_000;
+const MAX_FIELD_BYTES = 2000;
+const text = (v, max) => {
+    if (typeof v !== "string")
+        return null;
+    const s = v.trim();
+    return s && s.length <= max ? s : s ? s.slice(0, max) : null;
+};
+const isEmpty = (v) => v === undefined || v === null || (typeof v === "string" && v.trim() === "");
+/** Loose shape checks for the two field names nearly every site uses. A site
+ *  that needs more (a confirmation code, a country rule) adds `register.verify`. */
+function builtInCheck(field, value) {
+    if (field === "email") {
+        if (typeof value !== "string" || value.length > 254 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return "not-an-email";
+    }
+    if (field === "phone") {
+        if (typeof value !== "string" || !/^\+?[0-9][0-9 ().-]{4,30}$/.test(value))
+            return "not-a-phone-number";
+    }
+    return null;
+}
+export function createUsers(opts) {
+    const store = opts.store;
+    const now = opts.now ?? Date.now;
+    const log = opts.log ?? (() => { });
+    const required = [...new Set(opts.register?.required ?? [])];
+    const optional = [...new Set(opts.register?.optional ?? [])].filter((f) => !required.includes(f));
+    const verify = opts.register?.verify;
+    const visitor = opts.visitor ?? {};
+    const gapMs = (visitor.visitGapMinutes ?? 30) * 60_000;
+    const hub = new Hub(log);
+    const lock = new KeyedLock();
+    const lastTouch = new Map();
+    const iso = (t) => new Date(t).toISOString();
+    const blank = (userid) => ({
+        userid,
+        address: null,
+        name: null,
+        avatar: null,
+        punkId: null,
+        door: null,
+        status: "visitor",
+        profile: {},
+        firstSeen: null,
+        lastSeen: null,
+        visits: 0,
+        signIns: 0,
+    });
+    const missingOf = (profile) => required.filter((f) => isEmpty(profile?.[f]));
+    /** visitor or registered, from what the profile holds today. */
+    const statusFor = (user) => (missingOf(user.profile).length === 0 ? "registered" : "visitor");
+    function registration(user) {
+        const missing = user.status === "registered" ? [] : missingOf(user.profile);
+        const state = { status: user.status, required, optional, missing, due: false, refused: false };
+        if (user.status !== "visitor")
+            return state;
+        const t = now();
+        let over = false;
+        if (visitor.maxDays !== undefined && user.firstSeen) {
+            const deadline = Date.parse(user.firstSeen) + visitor.maxDays * DAY_MS;
+            state.deadline = iso(deadline);
+            if (t > deadline)
+                over = true;
+        }
+        if (visitor.maxVisits !== undefined) {
+            state.visitsLeft = Math.max(0, visitor.maxVisits - (user.visits || 0));
+            if ((user.visits || 0) > visitor.maxVisits)
+                over = true;
+        }
+        state.due = over;
+        state.refused = over && visitor.then === "refuse";
+        return state;
+    }
+    const get = async (userid) => (await store.get(userid)) ?? null;
+    async function list(filter) {
+        const all = await store.list();
+        return filter?.status ? all.filter((u) => u.status === filter.status) : all;
+    }
+    function emitLater(event, ...args) {
+        // Never awaited by the caller: a listener (the agent accepting a held
+        // request, a site sending a welcome) must not hold up the HTTP answer,
+        // and must be free to call back into this module.
+        void hub.emit(event, ...args);
+    }
+    async function recordSignIn(userid, hints = {}, info = {}) {
+        if (!isUserid(userid))
+            throw new TypeError("beagle-service: not a userid");
+        const events = [];
+        const user = await lock.run(userid, async () => {
+            const prev = await get(userid);
+            if (prev?.status === "blocked")
+                return prev;
+            const t = now();
+            const next = { ...blank(userid), ...prev };
+            const first = !prev || !prev.firstSeen;
+            // A blank or malformed hint never replaces a value already held: the
+            // address above all cannot be asked for again.
+            const address = addressOf(userid, hints.address);
+            if (address)
+                next.address = address;
+            const name = text(hints.name, 128);
+            if (name)
+                next.name = name;
+            const avatar = typeof hints.avatar === "string" && hints.avatar.length <= 4096 ? hints.avatar.trim() : "";
+            if (avatar)
+                next.avatar = avatar;
+            if (typeof hints.punkId === "number" && Number.isInteger(hints.punkId) && hints.punkId >= 0 && hints.punkId < 1_000_000) {
+                next.punkId = hints.punkId;
+            }
+            if (info.door)
+                next.door = info.door.slice(0, 200);
+            next.firstSeen ??= iso(t);
+            if (!prev?.lastSeen || t - Date.parse(prev.lastSeen) > gapMs)
+                next.visits = (next.visits || 0) + 1;
+            next.lastSeen = iso(t);
+            next.signIns = (next.signIns || 0) + 1;
+            const was = prev?.status;
+            next.status = statusFor(next);
+            if (next.status === "registered")
+                next.registeredAt ??= iso(t);
+            await store.put(next);
+            lastTouch.set(userid, t);
+            events.push(() => emitLater("sign-in", next, { first, door: next.door }));
+            if (next.status === "registered" && was !== "registered")
+                events.push(() => emitLater("registered", next));
+            return next;
+        });
+        for (const fire of events)
+            fire();
+        if (opts.importProfile && user.status !== "blocked")
+            void importProfile(userid).catch(() => { });
+        return user;
+    }
+    async function touch(userid) {
+        const t = now();
+        if (t - (lastTouch.get(userid) ?? 0) < TOUCH_EVERY_MS)
+            return get(userid);
+        return lock.run(userid, async () => {
+            const prev = await get(userid);
+            if (!prev || prev.status === "blocked")
+                return prev;
+            lastTouch.set(userid, t);
+            const next = { ...prev, lastSeen: iso(t) };
+            if (!prev.lastSeen || t - Date.parse(prev.lastSeen) > gapMs)
+                next.visits = (prev.visits || 0) + 1;
+            await store.put(next);
+            return next;
+        });
+    }
+    async function update(userid, patch) {
+        if (patch.status === "blocked")
+            throw new TypeError("beagle-service: use users.block(userid, why) to block");
+        const events = [];
+        const user = await lock.run(userid, async () => {
+            const prev = await get(userid);
+            if (!prev)
+                throw new Error(`beagle-service: no user ${userid}`);
+            if (prev.status === "blocked" && patch.status)
+                throw new TypeError("beagle-service: use users.unblock(userid) to unblock");
+            const next = {
+                ...prev,
+                ...patch,
+                userid: prev.userid,
+                profile: patch.profile ? { ...prev.profile, ...patch.profile } : prev.profile,
+            };
+            if (next.status === "registered" && prev.status !== "registered") {
+                next.registeredAt ??= iso(now());
+                events.push(() => emitLater("registered", next));
+            }
+            await store.put(next);
+            return next;
+        });
+        for (const fire of events)
+            fire();
+        return user;
+    }
+    async function register(userid, submitted) {
+        const current = await get(userid);
+        if (!current)
+            return { ok: false, error: "not-found" };
+        if (current.status === "blocked")
+            return { ok: false, error: "blocked" };
+        const body = submitted && typeof submitted === "object" ? submitted : {};
+        const errors = {};
+        const accepted = {};
+        // Checked outside the per-user lock: `verify` is the site's code and may
+        // be slow or call back into users.
+        for (const field of [...required, ...optional]) {
+            if (!Object.prototype.hasOwnProperty.call(body, field))
+                continue;
+            let value = body[field];
+            if (typeof value === "string")
+                value = value.trim();
+            if (isEmpty(value))
+                continue; // a required one is reported as missing below
+            let size = 0;
+            try {
+                size = Buffer.byteLength(JSON.stringify(value));
+            }
+            catch {
+                size = Infinity;
+            }
+            if (size > MAX_FIELD_BYTES) {
+                errors[field] = "too-long";
+                continue;
+            }
+            const bad = builtInCheck(field, value);
+            if (bad) {
+                errors[field] = bad;
+                continue;
+            }
+            if (verify) {
+                let verdict;
+                try {
+                    verdict = await verify(field, value, current, body);
+                }
+                catch (e) {
+                    log(`beagle-service: register.verify threw for "${field}": ${msgOf(e)}`);
+                    verdict = "could-not-verify";
+                }
+                if (verdict === false) {
+                    errors[field] = "not-accepted";
+                    continue;
+                }
+                if (typeof verdict === "string") {
+                    errors[field] = verdict;
+                    continue;
+                }
+                if (verdict && typeof verdict === "object")
+                    value = verdict.value;
+            }
+            accepted[field] = value;
+        }
+        const events = [];
+        const result = await lock.run(userid, async () => {
+            const prev = await get(userid);
+            if (!prev)
+                return { ok: false, error: "not-found" };
+            if (prev.status === "blocked")
+                return { ok: false, error: "blocked" };
+            const profile = { ...prev.profile, ...accepted };
+            for (const f of missingOf(profile))
+                errors[f] ??= "required";
+            if (Object.keys(errors).length)
+                return { ok: false, error: "invalid-fields", fields: errors };
+            const next = { ...prev, profile, status: "registered" };
+            next.registeredAt ??= iso(now());
+            await store.put(next);
+            if (prev.status !== "registered")
+                events.push(() => emitLater("registered", next));
+            return { ok: true, user: next };
+        });
+        for (const fire of events)
+            fire();
+        return result;
+    }
+    async function block(userid, why = "") {
+        if (!isUserid(userid))
+            throw new TypeError("beagle-service: not a userid");
+        let fire = false;
+        const user = await lock.run(userid, async () => {
+            const prev = (await get(userid)) ?? blank(userid);
+            if (prev.status === "blocked")
+                return prev;
+            const t = now();
+            const next = {
+                ...prev,
+                status: "blocked",
+                blocked: { at: iso(t), why: String(why).slice(0, 1000), was: prev.status },
+                // Sessions issued up to now are dead for good, also after an unblock.
+                sessionsValidFrom: t + 1,
+            };
+            await store.put(next);
+            fire = true;
+            return next;
+        });
+        if (fire)
+            emitLater("blocked", user);
+        return user;
+    }
+    async function unblock(userid) {
+        let fire = false;
+        const user = await lock.run(userid, async () => {
+            const prev = await get(userid);
+            if (!prev || prev.status !== "blocked")
+                return prev;
+            const next = { ...prev, blocked: null, status: "visitor" };
+            next.status = prev.blocked?.was === "registered" || (prev.firstSeen && statusFor(next) === "registered") ? "registered" : "visitor";
+            await store.put(next);
+            fire = true;
+            return next;
+        });
+        if (fire && user)
+            emitLater("unblocked", user);
+        return user;
+    }
+    async function revokeSessions(userid) {
+        await lock.run(userid, async () => {
+            const prev = await get(userid);
+            if (prev)
+                await store.put({ ...prev, sessionsValidFrom: now() + 1 });
+        });
+    }
+    // ── beagles.eth profile import ────────────────────────────────────────────
+    const gateway = (typeof opts.importProfile === "object" && opts.importProfile.gateway) || DEFAULT_PROFILE_GATEWAY;
+    const ttlMs = ((typeof opts.importProfile === "object" && opts.importProfile.ttlHours) || 24) * 3_600_000;
+    const noRecordUntil = new Map();
+    async function importProfile(userid) {
+        if (!isUserid(userid))
+            return null;
+        const t = now();
+        const user = await get(userid);
+        if (!user)
+            return null;
+        if (user.published?.fetchedAt && t - Date.parse(user.published.fetchedAt) < ttlMs)
+            return user.published;
+        if ((noRecordUntil.get(userid) ?? 0) > t)
+            return null;
+        const doFetch = opts.fetch ?? fetch;
+        let record;
+        try {
+            const r = await doFetch(`${gateway.replace(/\/+$/, "")}/getAddress/${userid}`, { signal: AbortSignal.timeout(5000) });
+            if (r.status === 404) {
+                noRecordUntil.set(userid, t + ttlMs);
+                return null;
+            }
+            if (!r.ok)
+                throw new Error(`HTTP ${r.status}`);
+            record = await r.json();
+        }
+        catch (e) {
+            log(`beagle-service: profile import for ${userid.slice(0, 8)} failed: ${msgOf(e)}`);
+            return null;
+        }
+        if (!record || typeof record !== "object" || typeof record.name !== "string") {
+            noRecordUntil.set(userid, t + ttlMs);
+            return null;
+        }
+        const texts = record.texts && typeof record.texts === "object" ? record.texts : {};
+        const published = { fetchedAt: iso(t) };
+        const put = (k, v, max) => {
+            const s = text(v, max);
+            if (s)
+                published[k] = s;
+        };
+        put("name", record.name, 255);
+        put("owner", record.owner, 128);
+        put("displayName", texts.displayName, 128);
+        put("description", texts.description, 1000);
+        put("avatar", texts.avatar, 2048);
+        put("url", texts.url, 2048);
+        const patch = { published };
+        // The record's address is a claim like the sign-in hint: used only when
+        // none is held, and only when it parses to this userid.
+        const address = addressOf(userid, texts.carrierAddress);
+        if (!user.address && address)
+            patch.address = address;
+        await update(userid, patch).catch(() => { });
+        return published;
+    }
+    return {
+        get,
+        list,
+        update,
+        block,
+        unblock,
+        revokeSessions,
+        register,
+        registration,
+        recordSignIn,
+        touch,
+        importProfile,
+        on: (event, cb) => hub.on(event, cb),
+    };
+}

package/dist/util.d.ts

@@ -0,0 +1,28 @@
+/** Write JSON so a crash leaves either the old file or the new one, never half
+ *  of one: write a sibling temp file, fsync it, rename it over the target. */
+export declare function atomicWriteJson(file: string, value: unknown, mode?: number): void;
+/** Read a JSON file. A missing file is the fallback; a file that is there but
+ *  does not parse throws, because treating it as empty would let the next
+ *  write replace real data with nothing. */
+export declare function readJsonFile<T>(file: string, fallback: T): T;
+/** A userid is the base58 of a 32-byte public key. */
+export declare function isUserid(v: unknown): v is string;
+/** The address when it is a well-formed Carrier address of `userid`, else null.
+ *  An address is not signed at sign-in, so the only thing that can be checked
+ *  is that it parses (key, nospam, checksum) and names the key that signed. */
+export declare function addressOf(userid: string, address: unknown): string | null;
+export declare const msgOf: (e: unknown) => string;
+export type Logger = (message: string) => void;
+/** A minimal typed event hub; a listener that throws never breaks the emitter. */
+export declare class Hub<Events extends Record<string, unknown[]>> {
+    #private;
+    constructor(log?: Logger);
+    on<K extends keyof Events>(event: K, cb: (...args: Events[K]) => unknown): () => void;
+    /** Runs listeners in registration order and waits for each. */
+    emit<K extends keyof Events>(event: K, ...args: Events[K]): Promise<void>;
+}
+/** Run async jobs for the same key one after another. */
+export declare class KeyedLock {
+    #private;
+    run<T>(key: string, job: () => Promise<T>): Promise<T>;
+}

package/dist/util.js

@@ -0,0 +1,107 @@
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+import { base58ToBytes, carrierIdFromAddress } from "@decentnetwork/peer";
+/** Write JSON so a crash leaves either the old file or the new one, never half
+ *  of one: write a sibling temp file, fsync it, rename it over the target. */
+export function atomicWriteJson(file, value, mode = 0o600) {
+    mkdirSync(dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    const fd = openSync(tmp, "w", mode);
+    try {
+        writeSync(fd, JSON.stringify(value, null, 2));
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    renameSync(tmp, file);
+}
+/** Read a JSON file. A missing file is the fallback; a file that is there but
+ *  does not parse throws, because treating it as empty would let the next
+ *  write replace real data with nothing. */
+export function readJsonFile(file, fallback) {
+    let raw;
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return fallback;
+        throw e;
+    }
+    if (raw.trim() === "")
+        return fallback;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (e) {
+        throw new Error(`beagle-service: ${file} is not valid JSON (${e.message}); fix or move it before starting`);
+    }
+}
+/** A userid is the base58 of a 32-byte public key. */
+export function isUserid(v) {
+    if (typeof v !== "string" || v.length < 32 || v.length > 64)
+        return false;
+    try {
+        return base58ToBytes(v).length === 32;
+    }
+    catch {
+        return false;
+    }
+}
+/** The address when it is a well-formed Carrier address of `userid`, else null.
+ *  An address is not signed at sign-in, so the only thing that can be checked
+ *  is that it parses (key, nospam, checksum) and names the key that signed. */
+export function addressOf(userid, address) {
+    if (typeof address !== "string" || address.length < 40 || address.length > 80)
+        return null;
+    try {
+        return carrierIdFromAddress(address) === userid ? address : null;
+    }
+    catch {
+        return null;
+    }
+}
+export const msgOf = (e) => e?.message ?? String(e);
+/** A minimal typed event hub; a listener that throws never breaks the emitter. */
+export class Hub {
+    #listeners = new Map();
+    #log;
+    constructor(log = () => { }) {
+        this.#log = log;
+    }
+    on(event, cb) {
+        let set = this.#listeners.get(event);
+        if (!set)
+            this.#listeners.set(event, (set = new Set()));
+        set.add(cb);
+        return () => set.delete(cb);
+    }
+    /** Runs listeners in registration order and waits for each. */
+    async emit(event, ...args) {
+        for (const cb of [...(this.#listeners.get(event) ?? [])]) {
+            try {
+                await cb(...args);
+            }
+            catch (e) {
+                this.#log(`beagle-service: a "${String(event)}" listener threw: ${msgOf(e)}`);
+            }
+        }
+    }
+}
+/** Run async jobs for the same key one after another. */
+export class KeyedLock {
+    #tails = new Map();
+    run(key, job) {
+        const prev = this.#tails.get(key) ?? Promise.resolve();
+        const next = prev.then(job, job);
+        const tail = next.catch(() => { });
+        this.#tails.set(key, tail);
+        void tail.then(() => {
+            if (this.#tails.get(key) === tail)
+                this.#tails.delete(key);
+        });
+        return next;
+    }
+}

package/examples/minimal-site/index.html

@@ -0,0 +1,91 @@
+<!doctype html>
+<html lang="en">
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Minimal site</title>
+<style>
+  body { font: 16px/1.5 system-ui, sans-serif; max-width: 34rem; margin: 3rem auto; padding: 0 1rem; }
+  button, input { font: inherit; padding: .5rem .8rem; margin: .2rem .2rem .2rem 0; }
+  code { word-break: break-all; }
+  #error { color: #b00020; }
+</style>
+<h1>Minimal site</h1>
+<div id="out">Loading…</div>
+<p id="error"></p>
+
+<script type="module">
+import { signIn, readLaunch, addFriend } from "/beagle-connect.js";
+
+// Two doors, one origin each: an https page cannot probe for an installed
+// Beagle, so the visitor says which one they use. A Beagle on another local
+// port: open this page with ?beagle=http://127.0.0.1:8767
+const local = new URLSearchParams(location.search).get("beagle");
+const DOORS = {
+  installed: /^http:\/\/(127\.0\.0\.1|localhost):\d+$/.test(local ?? "") ? local : "http://127.0.0.1:8766",
+  web: "https://app.beagle.chat",
+};
+const out = document.querySelector("#out");
+const fail = (e) => (document.querySelector("#error").textContent = e?.message ?? String(e));
+const api = async (path, body) => {
+  const r = await fetch(`/api/auth/${path}`, body ? { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) } : {});
+  return { status: r.status, ...(await r.json()) };
+};
+const el = (tag, props = {}, ...kids) => {
+  const n = Object.assign(document.createElement(tag), props);
+  n.append(...kids);
+  return n;
+};
+
+async function signInThrough(door) {
+  // Open the window inside the click: one opened after an await has lost the user gesture.
+  const win = window.open("about:blank", "beagle-connect", "width=420,height=560");
+  if (!win) return fail(new Error("Allow pop-ups for this site, then click again."));
+  try {
+    const { nonce } = await api("nonce");
+    const who = await signIn({ nonce, origins: [DOORS[door]], existingWindow: win });
+    render(await api("sign-in", who)); // { userid, address, name, avatar, sig, nonce, uiOrigin }
+  } catch (e) {
+    try { win.close(); } catch {}
+    fail(e);
+  }
+}
+
+function render(me) {
+  document.querySelector("#error").textContent = "";
+  out.replaceChildren();
+  if (!me.user) {
+    if (me.error && me.error !== "not-signed-in") fail(new Error(me.message));
+    out.append(
+      el("button", { textContent: "Sign in with Beagle (installed)", onclick: () => signInThrough("installed") }),
+      el("button", { textContent: "Sign in with Beagle in the browser", onclick: () => signInThrough("web") }),
+    );
+    return;
+  }
+  const { user, registration, agent } = me;
+  out.append(el("p", {}, `Signed in as ${user.name ?? "someone"} (${user.status}) `, el("code", { textContent: user.userid })));
+  if (registration.missing.length || registration.optional.length) {
+    const form = el("form", {}, el("p", { textContent: registration.due ? "Please register to go on:" : registration.missing.length ? "Register:" : "Your details:" }));
+    for (const f of [...registration.required, ...registration.optional]) {
+      form.append(el("input", { name: f, placeholder: f + (registration.required.includes(f) ? " (required)" : ""), value: user.profile[f] ?? "" }));
+    }
+    form.append(el("button", { textContent: "Save" }));
+    form.onsubmit = async (ev) => {
+      ev.preventDefault();
+      const r = await api("register", { profile: Object.fromEntries(new FormData(form)) });
+      r.ok ? render(r) : fail(new Error(Object.entries(r.fields ?? {}).map(([k, v]) => `${k}: ${v}`).join(", ") || r.message));
+    };
+    out.append(form);
+  }
+  if (agent) out.append(el("button", { textContent: `Add ${agent.name ?? "our agent"} on Beagle`, onclick: () => addFriend({ address: agent.address, name: agent.name }).catch(fail) }));
+  out.append(el("button", { textContent: "Sign out", onclick: async () => { await api("logout", {}); render({}); } }));
+  fetch("/api/hello").then((r) => r.json()).then((j) => out.append(el("p", { textContent: j.message ?? `The site's own route says: ${j.error}` })));
+}
+
+// Arrived from Beagle's Apps tab? Then the visitor is signed in already.
+try {
+  const launch = await readLaunch();
+  if (launch) await api("launch", launch);
+} catch (e) { fail(e); }
+render(await api("me"));
+</script>
+</html>

package/examples/minimal-site/server.mjs

@@ -0,0 +1,64 @@
+// A whole site on Beagle identity in one file.
+//   npm install @decentnetwork/beagle-service @decentnetwork/beagle-connect esbuild
+//   node server.mjs        →  http://localhost:3000
+import http from "node:http";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import { createBeagleService } from "@decentnetwork/beagle-service";
+
+const PORT = Number(process.env.PORT ?? 3000);
+const ORIGIN = process.env.ORIGIN ?? `http://localhost:${PORT}`; // exactly what the browser's address bar shows
+
+const svc = await createBeagleService({
+  origins: [ORIGIN],
+  dataDir: process.env.DATA_DIR ?? fileURLToPath(new URL("./data", import.meta.url)),
+  register: { required: ["email"], optional: ["location"] }, // [] = every visitor is a user at once
+  visitor: { maxDays: 14, then: "ask" },                     // "refuse" = 403 until they register
+  // The site's own Carrier identity. Leave it out if the site only needs sign-in.
+  agent: process.env.AGENT ? { nickname: "Minimal Site", accept: "signed-in", befriendOn: "register" } : undefined,
+});
+
+svc.agent?.onMessage(({ user, text, reply }) => reply(user ? `Hello ${user.name ?? "there"}, you said: ${text}` : "Sign in on the site first."));
+svc.users.on("registered", (user) => console.log(`registered: ${user.userid} ${JSON.stringify(user.profile)}`));
+
+// beagle-connect for the browser. It needs two functions of @decentnetwork/peer
+// (the signature check), so bundle those two modules instead of the whole peer.
+const peerForBrowser = {
+  name: "peer-for-browser",
+  setup(b) {
+    b.onResolve({ filter: /^@decentnetwork\/peer$/ }, () => ({ path: "peer", namespace: "shim" }));
+    b.onLoad({ filter: /.*/, namespace: "shim" }, () => ({
+      resolveDir: fileURLToPath(new URL(".", import.meta.url)),
+      contents: `export { verifyDetached } from "@decentnetwork/peer/dist/crypto/sign.js";
+                 export { base58ToBytes } from "@decentnetwork/peer/dist/utils/base58.js";`,
+    }));
+  },
+};
+const client = (await build({
+  entryPoints: [fileURLToPath(import.meta.resolve("@decentnetwork/beagle-connect"))],
+  bundle: true, format: "esm", platform: "browser", write: false, plugins: [peerForBrowser],
+})).outputFiles[0].text;
+
+const page = readFileSync(new URL("./index.html", import.meta.url));
+const auth = svc.nodeHandler({ prefix: "/api/auth" }); // nonce, sign-in, launch, me, logout, register
+const send = (res, status, type, body) => { res.writeHead(status, { "content-type": type, "cache-control": "no-store" }); res.end(body); };
+
+http.createServer(async (req, res) => {
+  const path = new URL(req.url, ORIGIN).pathname;
+  if (path.startsWith("/api/auth/")) return auth(req, res);
+  if (path === "/api/hello") {
+    // One of the site's own routes: who is asking?
+    const who = await svc.auth.authenticate(req);
+    if (!who.ok) return send(res, who.status, "application/json", JSON.stringify({ error: who.error }));
+    return send(res, 200, "application/json", JSON.stringify({ message: `Hello ${who.user.name ?? who.user.userid}, you are ${who.user.status}.` }));
+  }
+  if (path === "/beagle-connect.js") return send(res, 200, "text/javascript; charset=utf-8", client);
+  if (path === "/") return send(res, 200, "text/html; charset=utf-8", page);
+  send(res, 404, "text/plain", "not found");
+}).listen(PORT, () => {
+  console.log(`minimal-site: ${ORIGIN}`);
+  if (svc.agent) console.log(`agent address (add it in Beagle): ${svc.agent.address}`);
+});
+
+// To refuse someone:  await svc.users.block(userid, "spam")   (sign-in answers 403, sessions end, the agent drops them)