@opennodes/registry 0.1.3 → 0.1.5

package/bin.js

@@ -10,6 +10,9 @@ const registry = await startRegistry({
   // Persistent signing identity: explicit path, or derived from a file db; pg deployments set ONP_REGISTRY_KEY.
   keyPath: process.env.ONP_REGISTRY_KEY ?? (persistent ? `${dbPath}.key.pem` : (dbPath.startsWith('postgres') ? 'onp-registry-key.pem' : null)),
   allowPrivateTargets: process.env.ONP_ALLOW_PRIVATE === '1', // dev only: permit localhost nodes
+  registerPerHour: Number(process.env.ONP_REGISTER_PER_HOUR ?? 30),          // per client address
+  admitCooldownMs: Number(process.env.ONP_ADMIT_COOLDOWN_MS ?? 30 * 60_000),  // Stage B per node
+  trustProxy: process.env.ONP_TRUST_PROXY === '1',                            // behind Caddy / a CDN
   adminToken: process.env.ONP_ADMIN_TOKEN ?? null,
   stageC: process.env.ONP_STAGE_C === '0' ? null : {
     livenessIntervalMs: Number(process.env.ONP_LIVENESS_MS ?? 300_000),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opennodes/registry",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "OpenNodes (ONP) reference registry: node registration with proof-of-resource qualification (Stage A/B/C), transparent ranking, enforceable estimates, catalog importers (OpenRouter, Hugging Face, models.dev, Ollama), MCP surface, and the web app (catalog, chat, advisor, Node Builder)",
   "license": "Apache-2.0",
   "type": "module",

package/src/namespace.js

@@ -0,0 +1,39 @@
+// Namespace binding (ONP-3 §4): a node id is a reverse-DNS name, and only a host that
+// controls that DNS name may register it. Without this an HTTP challenge proves control of
+// *some* server, not of the namespace being claimed.
+
+/** org.example.ai.box -> box.ai.example.org */
+export const domainForNodeId = (nodeId) => String(nodeId).split('.').reverse().join('.').toLowerCase();
+
+/**
+ * True when `host` may serve the card and HTTP challenge for `nodeId`: the id's domain is the
+ * host itself or a name beneath it (the owner of example.org controls org.example.*).
+ * A *child* host never controls its parent's namespace (alice.github.io cannot claim io.github).
+ */
+export function hostControlsNamespace(host, nodeId) {
+  const h = String(host).toLowerCase().replace(/\.$/, '');
+  const domain = domainForNodeId(nodeId);
+  if (!h.includes('.')) return false;                       // a bare TLD / single label controls nothing
+  return domain === h || domain.endsWith('.' + h);
+}
+
+/** Loopback / private literal hosts: only acceptable in dev mode (allowPrivateTargets). */
+export function isPrivateHost(host) {
+  const h = String(host).toLowerCase().replace(/^\[|\]$/g, '');
+  return h === 'localhost' || h === '::1' || /^127\./.test(h) || /^10\./.test(h)
+    || /^192\.168\./.test(h) || /^172\.(1[6-9]|2\d|3[01])\./.test(h);
+}
+
+/** Fixed-window in-memory rate limiter keyed by client address. limit <= 0 disables it. */
+export function makeRateLimiter(limit, windowMs = 3_600_000) {
+  const hits = new Map();
+  return (key) => {
+    if (!(limit > 0)) return true;
+    const now = Date.now();
+    const rec = hits.get(key);
+    if (!rec || now - rec.start > windowMs) { hits.set(key, { start: now, n: 1 }); return true; }
+    rec.n += 1;
+    if (hits.size > 10_000) for (const [k, v] of hits) if (now - v.start > windowMs) hits.delete(k);
+    return rec.n <= limit;
+  };
+}

package/src/server.js

@@ -17,6 +17,7 @@ import { startReimport } from './reimport.js';
 import { makeSafeFetch } from './safefetch.js';
 import { searchOfferings, searchOfferingsPaged, collectOfferings, RANK_COMPONENTS } from './search.js';
 import { mcpRoutes } from './mcp.js';
+import { hostControlsNamespace, isPrivateHost, makeRateLimiter } from './namespace.js';
 import { exportRoutes } from './export.js';
 import {
   importModelsDev, importHuggingFace, importOpenRouter,
@@ -33,6 +34,10 @@ export async function startRegistry({
   reimport = null,                      // { intervalMs, sources } to keep imported catalogs fresh
   adminToken = null,                    // bearer for admin routes; without it, loopback-only
   keyPath = null,                       // PEM file for a persistent signing identity; null = ephemeral
+  enforceNamespace = null,              // null = enforce except for private hosts in dev mode; true/false to force
+  registerPerHour = 0,                  // per-client cap on register/verify calls (0 = unlimited; set in production)
+  admitCooldownMs = 0,                  // minimum gap between Stage B runs per node (0 = none; set in production)
+  trustProxy = false,                   // read the client address from X-Forwarded-For (behind Caddy / a CDN)
 } = {}) {
   const store = await createStore(dbPath); // sqlite path/:memory: or postgres:// URL
   const safeFetch = makeSafeFetch({ allowPrivate: allowPrivateTargets });
@@ -76,10 +81,23 @@ export async function startRegistry({
   /** node.id is reverse-DNS: org.opennodes.fixture -> fixture.opennodes.org */
   const domainForNodeId = (nodeId) => nodeId.split('.').reverse().join('.');
 
+  /** May `originUrl`'s host register `nodeId`? (ONP-3 §4: the host must control the id's DNS namespace.) */
+  const namespaceOk = (originUrl, nodeId) => {
+    const host = new URL(originUrl).hostname;
+    if (enforceNamespace === false) return true;
+    if (enforceNamespace !== true && allowPrivateTargets && isPrivateHost(host)) return true;   // dev / e2e on loopback
+    return hostControlsNamespace(host, nodeId);
+  };
+  const registerLimiter = makeRateLimiter(registerPerHour);
+  const clientOf = (req) => (trustProxy && req.headers['x-forwarded-for']?.split(',')[0].trim()) || req.socket.remoteAddress || 'unknown';
+  const isAdmin = (req) => Boolean(adminToken) && req.headers.authorization === `Bearer ${adminToken}`;
+
   async function challengeSatisfied(node, challenge) {
-    try { // HTTP method
-      const resp = await safeFetch(`${node.origin}/.well-known/onp-challenge/${challenge.token}`, {}, 10_000);
-      if (resp.ok) return { ok: true, method: 'http' };
+    try { // HTTP method — only from a host that controls the id's namespace
+      if (namespaceOk(node.origin, node.id)) {
+        const resp = await safeFetch(`${node.origin}/.well-known/onp-challenge/${challenge.token}`, {}, 10_000);
+        if (resp.ok) return { ok: true, method: 'http' };
+      }
     } catch { /* fall through to DNS */ }
     try { // DNS TXT method: _onp-challenge.{domain} TXT "{token}"
       const records = await dnsResolveTxt(`_onp-challenge.${domainForNodeId(node.id)}`);
@@ -118,6 +136,7 @@ export async function startRegistry({
 
   const app = createApp([
     ['POST', '/v0/nodes', async (req, res) => {
+      if (!registerLimiter(clientOf(req))) return problem(res, 429, 'rate-limited', 'too many registration attempts from this address; try again later');
       const { card_url } = await readJson(req);
       if (!card_url) return problem(res, 400, 'missing-card-url', 'body must be {"card_url": "..."}');
       let card;
@@ -127,13 +146,22 @@ export async function startRegistry({
 
       const nodeId = card.node.id;
       const origin = new URL(card_url).origin;
+      // The card must be served by a host that controls the claimed id (reverse-DNS). Otherwise anyone
+      // could host a card naming someone else's node and pass the HTTP challenge on their own server.
+      if (!namespaceOk(origin, nodeId)) {
+        return problem(res, 403, 'namespace-mismatch',
+          `node id ${nodeId} maps to ${domainForNodeId(nodeId)}; its card must be served from that host or a parent domain, not ${new URL(origin).hostname}`);
+      }
+      const existing = await store.getNode(nodeId);
+      const listed = existing && !['challenged', 'submitted'].includes(existing.state) && existing.source !== 'import';
       await store.upsertNode(nodeId, origin, card_url, 'challenged');
-      await store.setState(nodeId, 'challenged', 'registration received');
+      // Re-registration of a listed node issues a fresh challenge but never delists it: state moves at /verify.
+      if (!listed) await store.setState(nodeId, 'challenged', 'registration received');
       const token = randomUUID();
       await store.setChallenge(nodeId, token);
       sendJson(res, 202, {
         node_id: nodeId,
-        state: 'challenged',
+        state: listed ? existing.state : 'challenged',
         challenge: {
           methods: {
             http: `${origin}/.well-known/onp-challenge/${token}`,
@@ -146,6 +174,7 @@ export async function startRegistry({
     }],
 
     ['POST', '/v0/nodes/:id/verify', async (req, res, { params }) => {
+      if (!registerLimiter(clientOf(req))) return problem(res, 429, 'rate-limited', 'too many verification attempts from this address; try again later');
       const node = await store.getNode(params.id);
       if (!node) return problem(res, 404, 'unknown-node', params.id);
       const challenge = await store.getChallenge(params.id);
@@ -188,6 +217,13 @@ export async function startRegistry({
       if (node.state !== 'community' && node.state !== 'verified') {
         return problem(res, 409, 'wrong-state', `Stage B requires community tier, node is ${node.state}`);
       }
+      if (admitCooldownMs > 0 && !isAdmin(req)) {
+        const lastB = (await store.probesFor(params.id)).find((p) => p.stage === 'B');
+        const age = lastB ? Date.now() - Date.parse(lastB.at) : Infinity;
+        if (age < admitCooldownMs) {
+          return problem(res, 429, 'admission-cooldown', `Stage B ran ${Math.round(age / 60000)} min ago; next run allowed in ${Math.ceil((admitCooldownMs - age) / 60000)} min`);
+        }
+      }
       await refreshCard(params.id);
       const card = await store.latestCard(params.id);
       const stageB = await runStageB(store, params.id, card, { safeFetch, capacity: stageBCapacity });

package/src/web/index.html

@@ -983,11 +983,31 @@ async function loadChatTargets() {
   $('#ch-modenote').textContent = MODE_NOTES[$('#ch-mode').value] ?? '';
   if (!chat.offerings.length) {
     try {
-      const { offerings } = await api('/v0/offerings?limit=60&modality=text');
-      chat.offerings = offerings;
+      // Registered nodes answer straight from the browser with no key; imported catalog listings
+      // (OpenRouter, HF providers, models.dev) need the visitor's own key for that provider.
+      const [reg, all] = await Promise.all([
+        api('/v0/offerings?limit=60&modality=text&tier=community'),
+        api('/v0/offerings?limit=60&modality=text'),
+      ]);
+      const key = (o) => o.node_id + '/' + o.offering_id;
+      const ready = reg.offerings.filter((o) => o.source !== 'import');
+      const seen = new Set(ready.map(key));
+      const rest = all.offerings.filter((o) => !seen.has(key(o)));
+      const local = rest.filter((o) => o.local);            // Ollama library: runs on the visitor's own machine
+      const imports = rest.filter((o) => !o.local);
+      chat.offerings = [...ready, ...local, ...imports];
+      const opt = (o, i) => `<option value="${i}">${esc(o.model.name)} — ${esc(o.node_id)} — ${priceStr(o.pricing)}</option>`;
       $('#ch-add').innerHTML = '<option value="">+ Add a model…</option>'
-        + offerings.map((o, i) => `<option value="${i}">${esc(o.model.name)} — ${esc(o.node_id)} — ${priceStr(o.pricing)}</option>`).join('')
+        + (ready.length ? `<optgroup label="Ready to use — no key needed (${ready.length})">${ready.map((o, i) => opt(o, i)).join('')}</optgroup>` : '')
+        + (local.length ? `<optgroup label="On your machine — needs a local Ollama with this model pulled">${local.map((o, i) => opt(o, ready.length + i)).join('')}</optgroup>` : '')
+        + (imports.length ? `<optgroup label="Imported catalogs — your own API key required">${imports.map((o, i) => opt(o, ready.length + local.length + i)).join('')}</optgroup>` : '')
         + '<option value="custom">custom endpoint (local Ollama / any OpenAI server)</option>';
+      if (!chat.roster.length && ready.length && !sessionStorage.getItem('onp-advisor-handoff')) {
+        chat.roster.push({ offering: ready[0] });   // a newcomer can just type
+        renderRoster();
+        const log = $('#ch-log');
+        if (log && !chat.history.length) log.innerHTML = `<p class="sub" style="margin:0">Ready: <b>${esc(ready[0].model.name)}</b> on ${esc(ready[0].node_id)} (${esc(ready[0].tier)}, no key needed) is preselected — say something, or add more models on the right to compare.</p>`;
+      }
     } catch { $('#ch-add').innerHTML = '<option value="custom">custom endpoint</option>'; }
   }
   await applyAdvisorHandoff();
@@ -1099,6 +1119,7 @@ $('#ch-judge').addEventListener('change', refreshEstimate);
 function importKeyHint(offering, base, key) {
   if (!offering || offering.source !== 'import' || key) return null;
   const host = new URL(base).host;
+  if (offering.local || /^(localhost|127\.0\.0\.1|\[::1\])(:|$)/.test(host)) return null;   // your own machine: no key
   const where = host.includes('huggingface') ? 'a Hugging Face token (huggingface.co/settings/tokens)'
     : host.includes('openrouter') ? 'an OpenRouter API key (openrouter.ai/keys)' : `an API key for ${host}`;
   return `This is an imported catalog listing served by ${host}: your browser calls it directly, which needs ${where} — paste it in the API key field (stored only in this browser). Or run it locally with BYOK: npx @opennodes/cli gateway --key ${host}=<key>. Registered OpenNodes nodes need no key.`;
@@ -1189,7 +1210,8 @@ async function callTargetStream(t, messages, onDelta, maxTokens = 1024) {
 }
 
 const metaLine = (r) => [r.ttft != null ? `ttft ${r.ttft}ms · ` + r.ms + 'ms total' : r.ms + 'ms', r.usage ? `${r.usage.prompt_tokens}+${r.usage.completion_tokens} tok` : null, r.receipt ? 'receipt ✓' : null].filter(Boolean).join(' · ');
-const corsHint = ' — if this is a CORS/network error, the node must allow browser origins (local Ollama: set OLLAMA_ORIGINS)';
+const corsHint = (err) => /failed to fetch|networkerror|load failed/i.test(String(err?.message))
+  ? ' — network/CORS error: the node must allow browser origins (local Ollama: set OLLAMA_ORIGINS)' : '';
 
 function logEl(html) {
   if ($('#ch-log').querySelector('p.sub')) $('#ch-log').innerHTML = '';
@@ -1239,7 +1261,7 @@ async function runSingle(text) {
   } catch (err) {
     chat.history.pop();
     el.firstChild.textContent = '';
-    el.querySelector('.mm').innerHTML = '<span class="err">' + esc(err.message) + '</span>' + corsHint;
+    el.querySelector('.mm').innerHTML = '<span class="err">' + esc(err.message) + '</span>' + corsHint(err);
   }
 }
 
@@ -1259,7 +1281,7 @@ async function fanoutRound(labelPrefix, buildMessages, { remember = false } = {}
       }
       return { label: String.fromCharCode(65 + i), text: r.text, ok: true };
     } catch (err) {
-      cards[i].querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint + '</span>';
+      cards[i].querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint(err) + '</span>';
       return { label: String.fromCharCode(65 + i), ok: false };
     }
   }));
@@ -1346,7 +1368,7 @@ async function runPipeline(text) {
       el.querySelector('.ctext').textContent = r.text || '(empty)';
       el.querySelector('.mm').textContent = metaLine(r);
     } catch (err) {
-      el.querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint + ' — pipeline stopped</span>';
+      el.querySelector('.ctext').innerHTML = '<span class="err">' + esc(err.message) + '</span><span class="prov">' + corsHint(err) + ' — pipeline stopped</span>';
       return;
     }
   }