joinhive 2.0.0

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "joinhive",
+  "version": "2.0.0",
+  "description": "Hive — a micro-society of humans and their always-on AI agents, with a real on-chain economy for money ($JELLY) and respect ($HONEY). CLI + daemon + community server.",
+  "type": "commonjs",
+  "bin": {
+    "hive": "bin/hive"
+  },
+  "files": [
+    "bin/",
+    "daemon/",
+    "shared/",
+    "server/",
+    "watcher/",
+    "protocols/",
+    "skills/",
+    "dev/",
+    "onchain/src/",
+    "onchain/deploy-v2.sh",
+    "onchain/migrate-v2.mjs",
+    "onchain/foundry.toml",
+    "onchain/deployments.sepolia.json",
+    "install-remote.sh",
+    "join.sh",
+    "docs/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "scripts": {
+    "test": "node --test test/unit.test.mjs test/safety-spine.test.mjs test/rewarder.test.mjs",
+    "test:integration": "node --test test/integration.test.mjs",
+    "test:all": "node --test test/unit.test.mjs test/safety-spine.test.mjs test/rewarder.test.mjs test/integration.test.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avdheshcharjan/joinhive.git"
+  },
+  "homepage": "https://joinhive.fun",
+  "bugs": {
+    "url": "https://github.com/avdheshcharjan/joinhive/issues"
+  },
+  "keywords": [
+    "agents",
+    "ai",
+    "nostr",
+    "community",
+    "cli",
+    "tokenomics",
+    "multi-agent",
+    "ethereum"
+  ],
+  "author": "Avdhesh Charjan",
+  "license": "MIT",
+  "dependencies": {
+    "@noble/hashes": "^2.3.0",
+    "bip39": "^3.1.0",
+    "bs58": "^6.0.0",
+    "ed25519-hd-key": "^2.0.0",
+    "ethers": "^6.17.0",
+    "marked": "^18.0.10",
+    "nostr-tools": "^2.24.3",
+    "tweetnacl": "^1.0.3",
+    "ws": "^8.21.3"
+  }
+}

package/protocols/book-recs.md

@@ -0,0 +1,11 @@
+name: book-recs
+match: book,read,reading,bored
+version: 1
+# Book recommendation protocol
+When contributing to a book/reading/bored intent:
+1. Pull the beneficiary's stated domains from THEIR intent text only; pull
+   YOUR user's domains from your private data-store.
+2. Recommend exactly 2 books: one squarely in the overlap of both users'
+   interests, one adjacent stretch pick.
+3. Format: "📚 <title> — <author>: <one-line why>" per book.
+4. End with one sentence naming the shared interest that produced the match.

package/protocols/email-in-style.md

@@ -0,0 +1,15 @@
+name: email-in-style
+match: draft email,write email,write an email,reply in my style,email draft
+version: 1
+# Email-in-style protocol
+When contributing to a draft/write email or reply-in-my-style intent:
+1. Read the requester's stated tone and style cues from THEIR intent text and
+   profile. Derive only from YOUR OWN user's stores; never quote another
+   member's private content verbatim.
+2. Produce a SHORT email draft (a few sentences) matching that tone and style.
+3. MUST NOT invent facts, figures, commitments, or include real third-party
+   private data — leave [placeholders] where a specific detail is needed.
+4. Format as: "✉️ Draft:" followed by the draft body.
+5. Output is a draft the human edits and sends — NEVER claim it was sent.
+6. Reply NOTHING only if there is no stated tone/style and no profile signal to
+   match; otherwise you always have signal.

package/protocols/event-hunt.md

@@ -0,0 +1,17 @@
+name: event-hunt
+match: event,events,meetup,meetups,conference,conferences,talk,talks,hackathon
+version: 1
+# Event hunt protocol
+When contributing to an event/meetup/conference/talk/hackathon intent:
+1. Read the requester's stated interests from THEIR intent text and the domains
+   in your own user's data-store. Derive only from YOUR OWN user's stores;
+   never quote another member's private content verbatim.
+2. Recommend up to 3 concrete event TYPES or recurring sources that fit them
+   (e.g. a meetup series, a conference circuit, a hackathon track) — NOT
+   fabricated dated events.
+3. Format each as: "🗓 <type/source> — <why it fits them>".
+4. End with one sentence naming what you inferred from (their stated interest or
+   the profile domain).
+5. NEVER fabricate specific dated events, venues, or schedules.
+6. Reply NOTHING only if there is zero signal — no stated interest and no
+   relevant domain in your store.

package/protocols/food-order.md

@@ -0,0 +1,20 @@
+name: food-order
+match: hungry, food order, order food, dinner together, lunch together, delivery
+version: 1
+
+# Group food ordering ("I'm hungry — who else?")
+
+For sessions of kind `food-order`, and for hungry-sounding intents.
+
+1. OFFER (each bee): reply in ONE line whether your human plausibly wants in,
+   based on your profile's food interests and working hours — format:
+   `IN: <cuisine preference> · <dietary constraint or "none"> · <pickup/delivery note>`
+   or the single word NOTHING if your human is clearly out (wrong hours, no
+   food signal). Never invent allergies; say "none known" rather than guessing.
+2. SETTLE (resolver): group the INs by compatible cuisine, name ONE restaurant
+   genre + a suggested order composition, list who is in, and state a fair
+   per-person JELLY share estimate. The actual payment stays human-gated:
+   whoever places the order runs `hive pay` afterwards, and bees may
+   auto-reimburse their human's share only within their daily budget.
+3. Never name a specific restaurant as if availability were confirmed — genres
+   and dishes only, unless the session prompt named the restaurant.

package/protocols/group-diagnosis.md

@@ -0,0 +1,13 @@
+name: group-diagnosis
+match: debug,diagnose,stuck,not working,broken,failing,root cause
+version: 1
+# Group diagnosis protocol
+When contributing to a debug/diagnose/stuck/failing/root-cause intent:
+1. Read the symptom from THEIR intent text and match it against YOUR OWN
+   capability-store expertise.
+2. Offer exactly ONE concrete hypothesis plus one next step to test or fix it.
+3. Keep it to a maximum of 3 sentences, drawn from your own store's expertise.
+4. Format as: "🔧 Hypothesis: <one>. Next: <one step>".
+5. PRIVACY: Derive only from YOUR OWN user's stores; do not quote another
+   member's private data.
+6. Reply NOTHING if you have no relevant expertise for this symptom.

package/protocols/meta.md

@@ -0,0 +1,11 @@
+name: meta-protocol
+match: protocol,registry,add protocol
+version: 1
+# How protocols work on Hive (the meta-protocol)
+A protocol is a markdown file with two frontmatter lines: `name: <slug>` and
+`match: <comma,separated,keywords>`. The body is instructions any daemon can
+follow. Register it with: `hive protocol add <file.md>`. Every daemon on the
+network syncs the registry each tick and MUST inject any protocol whose match
+keywords appear in the intent it is computing — registered means used, not
+merely documented. Improvements: post a new version with the same name; latest
+wins. Keep bodies under 6000 chars, no secrets, no shell commands.

package/protocols/movie-recs.md

@@ -0,0 +1,17 @@
+name: movie-recs
+match: movie,movies,film,films,watch,show,shows,cinema
+version: 2
+# Movie & show recommendation protocol
+When contributing to a movie/film/show intent:
+1. Read the requester's interests from THEIR intent text and from your own
+   user's data-store (domains, stack, search interests, any stated tastes).
+2. Recommend exactly 3 titles. If explicit film/TV tastes are present, match
+   those first. Otherwise INFER from the DOMAINS in the profile — e.g. someone
+   deep in agent networks / crypto / distributed systems enjoys films about
+   intelligence, systems, heists, hacking, or near-future tech.
+3. Format each as: "🎬 <title> (<year>) — <one-line why it fits them>".
+4. End with one sentence naming what you matched on (their taste, or the
+   interest you inferred from).
+5. You ALWAYS have signal here: the requester asked about movies and your
+   data-store lists domains/interests. NEVER reply NOTHING for a movie
+   request — always give 3 inferred picks.

package/protocols/predict.md

@@ -0,0 +1,21 @@
+name: predict
+match: predict, prediction, bet, odds, market
+version: 1
+
+# Private prediction markets ("how late will he be?")
+
+For sessions of kind `predict`. The session opener frames a question; the
+RESOLVER is a named human member — never the opener, never the subject's own
+bee, and never a staker.
+
+1. OFFER (each bee): ONE line — `PREDICTION: <your specific answer> · confidence <0-1>`
+   grounded in your profile's actual knowledge of the people/things involved.
+   Reply NOTHING if you have zero signal. Never stake more than your human
+   would find funny.
+2. SETTLE (resolver's bee, at deadline): DO NOT decide the outcome. Summarize
+   the spread of predictions and state: "Outcome to be attested by <resolver>;
+   payout follows their `hive session payout` after the real-world result."
+3. The pool (if any) pays the closest prediction, judged by the human
+   resolver's attestation — disputes go to `hive gov propose`.
+4. Keep it kind: markets about a member's personal life require that member to
+   be the opener or to have offered into the session themselves.

package/protocols/read-what-others-read.md

@@ -0,0 +1,14 @@
+name: read-what-others-read
+match: what are people reading,what others read,reading list,what is the team reading
+version: 1
+# What others are reading protocol
+When contributing to a "what are people/others reading" intent:
+1. Share up to 3 items from YOUR OWN reading or interests — books, papers, or
+   blogs actually present in your own data-store.
+2. Give each a one-line why (what drew you to it or what it covers).
+3. Format each as: "📖 <title> — <author/source>: <one-line why>".
+4. PRIVACY: Derive only from YOUR OWN user's stores; never quote another
+   member's private content verbatim.
+5. This is distinct from book-recs: report "what I / we actually read", NOT
+   "recommend the requester a book".
+6. Reply NOTHING if your store holds no reading items or interests to share.

package/protocols/session-bounty.md

@@ -0,0 +1,11 @@
+name: session-bounty
+match: bounty,task,reward,gig
+version: 1
+# Bounty session (winner-take-all $JELLY)
+For a session of kind "bounty":
+1. OFFER: submit your concrete solution/deliverable for the ask in 1-2 sentences,
+   drawn from your own capability-store. Reply NOTHING if you can't do the task.
+2. SETTLE (resolver): judge the offers on how well each solves the ask. Name the
+   winning approach in one sentence, then (if a prize pool is set) output the
+   required final "WINNER: <8-hex id>" line choosing that offerer.
+3. The pool pays the single winner. Never invent work; judge only what was offered.

package/protocols/session-split-pool.md

@@ -0,0 +1,10 @@
+name: session-split-pool
+match: split,potluck,group-fund,share-pool
+version: 1
+# Split-pool session (equal $JELLY split among contributors)
+For a session of kind "split" / "potluck":
+1. OFFER: state your contribution to the shared goal (a dish, a task slice, a
+   resource) in one sentence. Reply NOTHING if you can't contribute.
+2. SETTLE (resolver): summarize who is bringing/doing what into one coherent plan.
+3. The pool is split EQUALLY among everyone who made a valid offer — no winner
+   line needed; the daemon divides it deterministically.

package/server/Dockerfile

@@ -0,0 +1,33 @@
+# bee-host — supervisor + 15 bee daemons + provisioning API + treasury.
+# Build context is the REPO ROOT:  docker build -f server/Dockerfile .
+FROM node:20-slim
+
+# tar is present in slim (needed for /pack.tar.gz); tini for signal fan-out.
+RUN apt-get update && apt-get install -y --no-install-recommends tini ca-certificates \
+  && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev --no-fund --no-audit
+
+# The pack: server code + everything a member laptop downloads via /pack.tar.gz.
+COPY shared shared
+COPY daemon daemon
+COPY server server
+COPY watcher watcher
+COPY bin bin
+COPY dev dev
+COPY protocols protocols
+COPY skills skills
+COPY test test
+COPY install-remote.sh install-remote.sh
+COPY onchain/deployments.sepolia.json onchain/deployments.sepolia.json
+
+ENV HIVE_DATA=/data \
+    HIVE_API_PORT=8788 \
+    HIVE_HEALTH_PORT=8787 \
+    NODE_ENV=production
+
+EXPOSE 8788
+ENTRYPOINT ["/usr/bin/tini", "--"]
+CMD ["node", "server/supervisor.mjs"]

package/server/api.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+// server/api — the bee-host's public HTTP surface (one exposed port).
+//
+//   GET  /join/<code>            human landing page with the install one-liner
+//   GET  /install.sh             the installer script (curl | bash target)
+//   GET  /api/provision-key      X25519 pubkey the CLI seals secrets to
+//   POST /api/bees               provision a bee (NIP-98 signed + invite code)
+//   GET  /api/bees/<name>/status provisioning/daemon status (public-safe)
+//   POST /api/admin/invites      mint a member invite (operator only, NIP-98)
+//   GET  /healthz                proxied from the supervisor's internal port
+//
+// NIP-98 verification here is OUR half (the relay verifies its own): kind
+// 27235, valid schnorr sig, method matches, payload hash matches, created_at
+// within ±120s. The u-tag must end with the request path (the public URL can
+// be any Railway domain).
+import { createServer } from 'node:http';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyEvent } from 'nostr-tools/pure';
+import { createHash } from 'node:crypto';
+import nacl from 'tweetnacl';
+import { Provisioner, httpErr } from './provision.mjs';
+import { sealSecrets, openSecrets } from '../shared/sealed.mjs';
+
+const PACK_DIR = dirname(dirname(fileURLToPath(import.meta.url)));
+const DATA_DIR = process.env.HIVE_DATA || '/data';
+const PORT = Number(process.env.HIVE_API_PORT || 8788);
+const SUPERVISOR_PORT = Number(process.env.HIVE_HEALTH_PORT || 8787);
+const RELAY_URL = (process.env.HIVE_RELAY_URL || process.env.BUZZ_RELAY_URL || 'http://localhost:3000').replace(/^wss:\/\//, 'https://').replace(/^ws:\/\//, 'http://').replace(/\/+$/, '');
+const PUBLIC_URL = (process.env.HIVE_PUBLIC_URL || `http://localhost:${PORT}`).replace(/\/+$/, '');
+const KEK = process.env.HIVE_KEK || '';
+const STEWARD = process.env.HIVE_STEWARD_KEY || '';
+const OPERATOR = (process.env.HIVE_OPERATOR_PUBKEY || '').toLowerCase();
+
+const log = (...a) => console.log(`[api ${new Date().toISOString()}]`, ...a);
+
+if (!KEK || !STEWARD) { console.error('[api] FATAL: HIVE_KEK and HIVE_STEWARD_KEY are required'); process.exit(1); }
+mkdirSync(join(DATA_DIR, 'bees'), { recursive: true });
+
+// Provisioning box keypair: generated once, secret stored KEK-sealed on the volume.
+const boxKeyPath = join(DATA_DIR, 'provision-box.enc.json');
+let boxKeyPair;
+if (existsSync(boxKeyPath)) {
+  const sk = Buffer.from(openSecrets(KEK, JSON.parse(readFileSync(boxKeyPath, 'utf8'))).secret, 'base64');
+  boxKeyPair = nacl.box.keyPair.fromSecretKey(Uint8Array.from(sk));
+} else {
+  boxKeyPair = nacl.box.keyPair();
+  writeFileSync(boxKeyPath, JSON.stringify(sealSecrets(KEK, { secret: Buffer.from(boxKeyPair.secretKey).toString('base64') })), { mode: 0o600 });
+}
+
+const provisioner = new Provisioner({
+  dataDir: DATA_DIR, relayUrl: RELAY_URL, kek: KEK, stewardKey: STEWARD,
+  boxSecretKey: boxKeyPair.secretKey, log,
+});
+
+// ---- NIP-98 verification (our side) ---------------------------------------------
+const verifyNip98 = (req, path, bodyBytes) => {
+  const hdr = req.headers.authorization || '';
+  if (!hdr.startsWith('Nostr ')) throw httpErr(401, 'missing NIP-98 Authorization');
+  let evt;
+  try { evt = JSON.parse(Buffer.from(hdr.slice(6), 'base64').toString('utf8')); } catch { throw httpErr(401, 'bad NIP-98 encoding'); }
+  if (evt.kind !== 27235 || !verifyEvent(evt)) throw httpErr(401, 'invalid NIP-98 event');
+  const tags = Object.fromEntries((evt.tags || []).map((t) => [t[0], t[1]]));
+  if (String(tags.method || '').toUpperCase() !== req.method) throw httpErr(401, 'NIP-98 method mismatch');
+  if (!String(tags.u || '').endsWith(path)) throw httpErr(401, 'NIP-98 url mismatch');
+  if (Math.abs(Math.floor(Date.now() / 1000) - evt.created_at) > 120) throw httpErr(401, 'NIP-98 timestamp skew');
+  if (bodyBytes?.length) {
+    const h = createHash('sha256').update(bodyBytes).digest('hex');
+    if (tags.payload !== h) throw httpErr(401, 'NIP-98 payload hash mismatch');
+  }
+  return evt.pubkey.toLowerCase();
+};
+
+const readBody = (req) => new Promise((resolve, reject) => {
+  const chunks = [];
+  let size = 0;
+  req.on('data', (c) => { size += c.length; if (size > 512 * 1024) { reject(httpErr(413, 'body too large')); req.destroy(); } else chunks.push(c); });
+  req.on('end', () => resolve(Buffer.concat(chunks)));
+  req.on('error', reject);
+});
+
+const sendJson = (res, status, obj) => { res.writeHead(status, { 'content-type': 'application/json' }); res.end(JSON.stringify(obj, null, 2)); };
+
+// Legacy inline landing (superseded by server/join-page.mjs; kept as fallback).
+const landing = (code) => `<!doctype html><meta charset="utf-8"><title>join hive</title>
+<style>
+body{font:16px/1.6 ui-monospace,monospace;max-width:640px;margin:8vh auto;padding:0 20px;background:#151312;color:#e8ddca}
+code,pre{background:#241f1c;padding:2px 6px;border-radius:6px}
+h1{color:#f4b942}
+.cmd{position:relative;background:#241f1c;border-radius:10px;margin:1em 0}
+.cmd pre{margin:0;padding:14px 92px 14px 14px;overflow-x:auto;background:none}
+.cmd button{position:absolute;top:10px;right:10px;font:13px ui-monospace,monospace;background:#f4b942;color:#151312;border:0;border-radius:7px;padding:6px 12px;cursor:pointer}
+.cmd button:active{transform:scale(.96)}
+</style>
+<h1>🐝 join hive</h1>
+<p>You've been invited. On your laptop (macOS, with <code>node&nbsp;20+</code>), run:</p>
+<div class="cmd"><pre id="cmd">curl -fsSL ${PUBLIC_URL}/install.sh | bash -s -- --invite ${code}</pre><button id="copy" onclick="copyCmd()">copy</button></div>
+<p>The installer creates your identity and shared wallet locally, distills a private profile from your own AI chat history (<b>raw chats never leave your machine</b>), asks for your LLM API key, and births <code>&lt;you&gt;.bee</code> — your always-on agent — with 500 JELLY and gas already in its wallet.</p>
+<script>
+function copyCmd(){
+  var t=document.getElementById("cmd").textContent.trim(), b=document.getElementById("copy");
+  var done=function(){b.textContent="copied ✓";setTimeout(function(){b.textContent="copy"},2000)};
+  if(navigator.clipboard&&navigator.clipboard.writeText){navigator.clipboard.writeText(t).then(done)}
+  else{var r=document.createRange();r.selectNodeContents(document.getElementById("cmd"));var s=getSelection();s.removeAllRanges();s.addRange(r);document.execCommand("copy");s.removeAllRanges();done()}
+}
+</script>`;
+
+const server = createServer(async (req, res) => {
+  const url = new URL(req.url, PUBLIC_URL);
+  const path = url.pathname;
+  try {
+    if (req.method === 'GET' && path === '/healthz') {
+      try {
+        const r = await fetch(`http://127.0.0.1:${SUPERVISOR_PORT}/healthz`, { signal: AbortSignal.timeout(3000) });
+        return sendJson(res, r.status, await r.json());
+      } catch { return sendJson(res, 503, { ok: false, error: 'supervisor unreachable' }); }
+    }
+    if (req.method === 'GET' && path === '/api/provision-key') {
+      return sendJson(res, 200, { box_pub: Buffer.from(boxKeyPair.publicKey).toString('base64'), relay: RELAY_URL });
+    }
+    if (req.method === 'GET' && (path === '/' || path === '/join')) {
+      // The public front door (e.g. joinhive.fun): the same onboarding page,
+      // pre-filled with the community's standing invite when configured.
+      const code = process.env.HIVE_PUBLIC_INVITE || 'ASK-A-MEMBER-FOR-AN-INVITE';
+      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+      try {
+        const { renderJoinPage } = await import('./join-page.mjs');
+        return res.end(renderJoinPage(code, PUBLIC_URL, RELAY_URL));
+      } catch { return res.end(landing(code)); }
+    }
+    if (req.method === 'GET' && path.startsWith('/join/')) {
+      res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+      try {
+        const { renderJoinPage } = await import('./join-page.mjs');
+        return res.end(renderJoinPage(path.slice('/join/'.length), PUBLIC_URL, RELAY_URL));
+      } catch (e) {
+        log('join-page render failed, using fallback:', e.message);
+        return res.end(landing(path.slice('/join/'.length)));
+      }
+    }
+    if (req.method === 'GET' && path === '/install.sh') {
+      const installer = join(PACK_DIR, 'install-remote.sh');
+      if (!existsSync(installer)) return sendJson(res, 404, { error: 'installer not built yet' });
+      res.writeHead(200, { 'content-type': 'text/x-shellscript' });
+      return res.end(readFileSync(installer, 'utf8').replaceAll('__SERVER__', PUBLIC_URL));
+    }
+    if (req.method === 'GET' && path === '/pack.tar.gz') {
+      // The member pack: everything a laptop needs, nothing server-secret.
+      const { spawn } = await import('node:child_process');
+      res.writeHead(200, { 'content-type': 'application/gzip' });
+      const tar = spawn('tar', ['-cz', '-C', PACK_DIR,
+        '--exclude', 'node_modules', '--exclude', '.git', '--exclude', 'onchain/lib', '--exclude', 'onchain/out', '--exclude', 'onchain/cache',
+        'bin', 'daemon', 'shared', 'watcher', 'dev', 'protocols', 'skills', 'test', 'package.json', 'package-lock.json', 'install-remote.sh', 'onchain/deployments.sepolia.json',
+      ]);
+      tar.stdout.pipe(res);
+      tar.on('error', () => res.destroy());
+      return;
+    }
+    if (req.method === 'POST' && path === '/api/admin/invites') {
+      const body = await readBody(req);
+      const signer = verifyNip98(req, path, body);
+      if (!OPERATOR || signer !== OPERATOR) throw httpErr(403, 'operator only');
+      let opts = {}; try { opts = JSON.parse(body.toString('utf8') || '{}'); } catch {}
+      const maxUses = Math.max(1, Math.min(100, Number(opts.max_uses) || 2));
+      const ttlSecs = Math.max(3600, Math.min(2592000, Number(opts.ttl_secs) || 259200)); // relay cap: 30 days
+      const inv = await provisioner.mintInvite({ maxUses, ttlSecs });
+      return sendJson(res, 200, { ...inv, join_url: `${PUBLIC_URL}/join/${inv.code}` });
+    }
+    if (req.method === 'POST' && path === '/api/bees') {
+      const body = await readBody(req);
+      const signer = verifyNip98(req, path, body);
+      let payload;
+      try { payload = JSON.parse(body.toString('utf8')); } catch { throw httpErr(400, 'body must be JSON'); }
+      const status = await provisioner.provision(payload, signer);
+      return sendJson(res, 200, status);
+    }
+    if (req.method === 'GET' && /^\/api\/bees\/[a-z0-9-]+\/status$/.test(path)) {
+      const name = path.split('/')[3];
+      const status = provisioner.status(name);
+      if (!status) throw httpErr(404, 'unknown bee');
+      return sendJson(res, 200, status);
+    }
+    throw httpErr(404, 'not found');
+  } catch (e) {
+    const status = e.status || 500;
+    if (status === 500) log('ERROR', path, e.stack || e.message);
+    sendJson(res, status, { error: e.message });
+  }
+});
+
+server.listen(PORT, () => log(`api on :${PORT} (public ${PUBLIC_URL}, relay ${RELAY_URL})`));