fix(pit): allow numeric hostname labels (#119)

Author: rissrice2105-agent

apps/pwa/src/lib/moshpit-name.mjs

@@ -28,20 +28,25 @@ export const RESERVED_TLDS = new Set([
 /** A TLD label: lowercase letters, digits and dashes; no leading/trailing dash. */
 const LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
 
+/** A hostname label. Unlike a TLD, an all-numeric label is valid. */
+export function normalizeLabel(input) {
+  const raw = String(input ?? "").trim().toLowerCase();
+  return raw && raw.length <= 63 && LABEL.test(raw) ? raw : null;
+}
+
 /**
  * Normalise user input into a bare TLD label, or null when it could never be
  * one. Accepts ".eggs", "eggs", " .EGGS " -- people type the dot.
  */
 export function normalizeTld(input) {
   const raw = String(input ?? "").trim().toLowerCase().replace(/^\.+/, "");
-  if (!raw || raw.length > 63) return null;
   // A dot means they gave a domain, not a TLD. Say so rather than silently
   // registering the wrong thing.
-  if (raw.includes(".")) return null;
-  if (!LABEL.test(raw)) return null;
+  const label = normalizeLabel(raw);
+  if (!label) return null;
   // All-numeric would be ambiguous against an IPv4 literal in a hostname.
-  if (/^\d+$/.test(raw)) return null;
-  return raw;
+  if (/^\d+$/.test(label)) return null;
+  return label;
 }
 
 /** Why a TLD cannot be registered, or null when it is fine. */
@@ -64,10 +69,10 @@ export function parseMoshpitName(input) {
   const parts = raw.split(".");
   if (parts.length !== 2) return null;
   const [label, tld] = parts;
-  // Both halves are hostname labels, and normalizeTld already encodes exactly
-  // that rule -- so reuse it rather than keeping a second copy that can drift.
-  if (!normalizeTld(label) || !normalizeTld(tld)) return null;
-  return { label, tld };
+  const normalizedLabel = normalizeLabel(label);
+  const normalizedTld = normalizeTld(tld);
+  if (!normalizedLabel || !normalizedTld) return null;
+  return { label: normalizedLabel, tld: normalizedTld };
 }
 
 /* ---- resolution precedence (tronbrowser.dev) ---- */

apps/pwa/src/moshpit.mjs

@@ -11,10 +11,10 @@
 // checkable rather than trusted.
 
 import { get, all, run } from "./db.mjs";
-import { normalizeTld, parseMoshpitName, tldRejection } from "./lib/moshpit-name.mjs";
+import { normalizeLabel, normalizeTld, parseMoshpitName, tldRejection } from "./lib/moshpit-name.mjs";
 
 export {
-  RESERVED_TLDS, RESOLVE_MODES, normalizeTld, parseMoshpitName, tldRejection,
+  RESERVED_TLDS, RESOLVE_MODES, normalizeLabel, normalizeTld, parseMoshpitName, tldRejection,
   normalizeMode, resolutionPreference,
 } from "./lib/moshpit-name.mjs";
 
@@ -174,7 +174,7 @@ export async function clearExempt({ tld: tldInput, label: labelInput, userId })
 
 async function ownedTldAndLabel(tldInput, labelInput, userId) {
   const tld = normalizeTld(tldInput);
-  const label = normalizeTld(labelInput);
+  const label = normalizeLabel(labelInput);
   if (!tld || !label) return { ok: false, error: "not a valid name" };
   const owner = await getTld(tld);
   if (!owner) return { ok: false, error: `.${tld} is not registered` };

apps/pwa/test/moshpit-name.test.mjs

@@ -5,7 +5,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
-  RESERVED_TLDS, normalizeTld, tldRejection, parseMoshpitName,
+  RESERVED_TLDS, normalizeLabel, normalizeTld, tldRejection, parseMoshpitName,
   normalizeMode, resolutionPreference,
 } from "../src/lib/moshpit-name.mjs";
 
@@ -29,6 +29,12 @@ test("normalizeTld rejects what could never be a TLD", () => {
   assert.equal(normalizeTld(undefined), null);
 });
 
+test("hostname labels may be numeric even though TLDs may not", () => {
+  assert.equal(normalizeLabel("123"), "123");
+  assert.equal(normalizeTld("123"), null);
+  assert.deepEqual(parseMoshpitName("123.eggs"), { label: "123", tld: "eggs" });
+});
+
 test("reserved names cannot be claimed", () => {
   for (const name of ["bank", "apple", "gov", "moshpit", "com"]) {
     assert.ok(RESERVED_TLDS.has(name), `${name} should be reserved`);
@@ -45,6 +51,7 @@ test("a TLD needs at least two characters", () => {
 test("parseMoshpitName splits exactly one dot", () => {
   assert.deepEqual(parseMoshpitName("foo.agentic"), { label: "foo", tld: "agentic" });
   assert.deepEqual(parseMoshpitName(" FOO.Agentic "), { label: "foo", tld: "agentic" });
+  assert.deepEqual(parseMoshpitName("123.agentic"), { label: "123", tld: "agentic" });
   assert.equal(parseMoshpitName("a.b.c"), null, "the namespace is one level deep");
   assert.equal(parseMoshpitName("nodot"), null);
   assert.equal(parseMoshpitName(""), null);

apps/pwa/test/moshpit-registry.test.mjs

@@ -108,6 +108,14 @@ test("moshpit registry", { skip: installed ? false : "pwa dependencies not insta
     assert.equal((await m.resolveMoshpitName("other.agentic")).resolved, "other.agent");
   });
 
+  await t.test("numeric labels resolve and can be exempted", async () => {
+    assert.equal((await m.resolveMoshpitName("123.agentic")).resolved, "123.agent");
+    assert.equal((await m.setExempt({ tld: "agentic", label: "123", userId: ALICE })).ok, true);
+    const r = await m.resolveMoshpitName("123.agentic");
+    assert.equal(r.resolved, "123.agentic");
+    assert.equal(r.exempt, true);
+  });
+
   await t.test("exemptions survive the alias being repointed", async () => {
     await m.clearAlias("agentic", ALICE);
     await m.setAlias({ from: "agentic", to: "agents", userId: ALICE });