pinomad 0.4.0 → 0.6.0

package/dist/{chunk-vw5yb5pd.js → chunk-wqvp1fwh.js}

@@ -2,35 +2,36 @@
 import {
   serveWebClient
 } from "./chunk-r6w5aqkw.js";
-import {
-  relayWsBase
-} from "./chunk-knaw1a9g.js";
-import {
-  commandHint,
-  webRoot
-} from "./chunk-fgx2sh7d.js";
 import {
   RELAY_CLOSE,
   decodeHostToRelay,
   encodeRelayFrame,
+  relayWsBase,
   verifyRelayChallenge,
   verifyRelayChallengeV2
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-7qb9tq54.js";
+import {
+  commandHint,
+  webRoot
+} from "./chunk-c8nxym2z.js";
+import {
+  normalizeHostName
+} from "./chunk-znhn8af7.js";
 import"./chunk-df32avw6.js";
 
-// apps/relay/src/main.ts
+// apps/server/src/main.ts
 import { homedir } from "node:os";
 import { join as join2, resolve } from "node:path";
 import { parseArgs } from "node:util";
 
-// apps/relay/src/accounts.ts
+// apps/server/src/accounts.ts
 import { createHash, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { promisify } from "node:util";
 
-// apps/relay/src/lock.ts
+// apps/server/src/lock.ts
 import lockfile from "proper-lockfile";
 async function lockDataDir(dir, options) {
   const stale = Math.max(2000, options?.staleMs ?? 1e4);
@@ -44,6 +45,8 @@ async function lockDataDir(dir, options) {
         throw error;
     }
   }).catch((error) => {
+    if (error.code !== "ELOCKED")
+      throw error;
     throw new Error(`Data directory is already in use by a running process: ${dir}`, { cause: error });
   });
   return async () => {
@@ -52,7 +55,7 @@ async function lockDataDir(dir, options) {
   };
 }
 
-// apps/relay/src/accounts.ts
+// apps/server/src/accounts.ts
 var DB_FILE = "server.sqlite";
 var SCHEMA_VERSION = 1;
 var SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
@@ -325,7 +328,7 @@ async function openAccounts(options) {
           db.exec("ROLLBACK");
           return { status: "refused", reason: failure };
         }
-        const hostName = name === undefined || name.trim() === "" ? "Unknown host" : name.trim().slice(0, 64);
+        const hostName = name === undefined ? "Unknown host" : normalizeHostName(name);
         db.prepare(`INSERT INTO hosts (host_id, user_id, noise_public_key, name, joined_at, last_seen_at)
            VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(host_id) DO UPDATE SET
@@ -358,6 +361,9 @@ async function openAccounts(options) {
     markHostSeen(hostId) {
       db.prepare("UPDATE hosts SET last_seen_at = ? WHERE host_id = ?").run(now(), hostId);
     },
+    renameHost(hostId, name) {
+      db.prepare("UPDATE hosts SET name = ? WHERE host_id = ?").run(normalizeHostName(name), hostId);
+    },
     async close() {
       db.close();
       await release();
@@ -394,13 +400,220 @@ async function changePassword(options) {
   }
 }
 
-// apps/relay/src/relay.ts
+// apps/server/src/apns.ts
+import { createPrivateKey, sign } from "node:crypto";
+import { connect } from "node:http2";
+var AUTHORITIES = {
+  production: "https://api.push.apple.com",
+  development: "https://api.sandbox.push.apple.com"
+};
+var PAYLOAD_MAX_BYTES = 4096;
+var EXPIRATION_SECONDS = 3600;
+var TOKEN_REFRESH_MS = 45 * 60 * 1000;
+var REQUEST_TIMEOUT_MS = 8000;
+var SERVER_ERROR_RETRY_MS = 15 * 60 * 1000;
+var base64url = (text) => Buffer.from(text, "utf8").toString("base64url");
+function loadApnsConfig(env = process.env) {
+  const teamId = env.PINOMAD_SERVER_APNS_TEAM_ID?.trim();
+  const topic = env.PINOMAD_SERVER_APNS_TOPIC?.trim();
+  if (teamId === undefined || teamId === "" || topic === undefined || topic === "")
+    return;
+  const loadEnv = (name) => {
+    const keyId = env[`PINOMAD_SERVER_APNS_${name}_KEY_ID`]?.trim();
+    const keyPem = env[`PINOMAD_SERVER_APNS_${name}_KEY`]?.replace(/\\n/g, `
+`).trim();
+    if (keyId === undefined && keyPem === undefined)
+      return;
+    if (keyId === undefined || keyId === "" || keyPem === undefined || keyPem === "") {
+      console.error(`apns: PINOMAD_SERVER_APNS_${name}_KEY and _KEY_ID must both be set — environment disabled`);
+      return;
+    }
+    return { keyId, keyPem };
+  };
+  const production = loadEnv("PRODUCTION");
+  const development = loadEnv("DEVELOPMENT");
+  return {
+    teamId,
+    topic,
+    environments: {
+      ...production === undefined ? {} : { production },
+      ...development === undefined ? {} : { development }
+    }
+  };
+}
+function providerToken(key, keyId, teamId, iatSeconds) {
+  const signingInput = `${base64url(JSON.stringify({ alg: "ES256", kid: keyId }))}.${base64url(JSON.stringify({ iss: teamId, iat: iatSeconds }))}`;
+  const signature = sign("sha256", Buffer.from(signingInput, "utf8"), { key, dsaEncoding: "ieee-p1363" });
+  return `${signingInput}.${signature.toString("base64url")}`;
+}
+function openApns(config) {
+  const states = new Map;
+  for (const environment of ["production", "development"]) {
+    const env = config.environments[environment];
+    if (env === undefined)
+      continue;
+    try {
+      states.set(environment, {
+        key: createPrivateKey(env.keyPem),
+        keyId: env.keyId,
+        authority: env.authority ?? AUTHORITIES[environment]
+      });
+    } catch {
+      console.error(`apns: the ${environment} key is not a valid EC private key — environment disabled`);
+    }
+  }
+  const environments = [...states.keys()];
+  const bearerFor = (state) => {
+    const now = Date.now();
+    if (state.token !== undefined && now - state.token.issuedAt < TOKEN_REFRESH_MS)
+      return state.token.jwt;
+    const jwt = providerToken(state.key, state.keyId, config.teamId, Math.floor(now / 1000));
+    state.token = { jwt, issuedAt: now };
+    return jwt;
+  };
+  const sessionFor = (environment, state) => {
+    const existing = state.session;
+    if (existing !== undefined && !existing.destroyed && !existing.closed)
+      return existing;
+    const session = connect(state.authority);
+    const drop = () => {
+      if (state.session === session)
+        state.session = undefined;
+      if (!session.destroyed)
+        session.destroy();
+    };
+    session.once("goaway", drop);
+    session.once("error", drop);
+    session.once("close", () => {
+      if (state.session === session)
+        state.session = undefined;
+    });
+    state.session = session;
+    return session;
+  };
+  const payloadFor = (notification) => JSON.stringify({
+    aps: {
+      alert: { title: notification.title, body: notification.body },
+      sound: "default",
+      "thread-id": notification.collapseId
+    },
+    hostKey: notification.hostKey,
+    conversationId: notification.conversationId
+  });
+  const classify = (environment, status, headers, body, state) => {
+    const reason = typeof body?.reason === "string" ? body.reason : `HTTP ${status}`;
+    const timestamp = body?.timestamp;
+    if (status === 200)
+      return { result: "accepted", reason: "ok" };
+    if (status === 410) {
+      return {
+        result: "unregistered",
+        reason,
+        unregisteredAt: typeof timestamp === "number" ? timestamp : Date.now()
+      };
+    }
+    if (status === 403 && reason === "ExpiredProviderToken") {
+      state.token = undefined;
+      return { result: "retry", reason };
+    }
+    if (reason === "InvalidProviderToken" || reason === "TooManyProviderTokenUpdates") {
+      console.error(`apns: provider token problem for ${environment}: ${reason}`);
+      return { result: "rejected", reason };
+    }
+    if (status === 429) {
+      const retryAfter = Number(headers["retry-after"]);
+      return {
+        result: "retry",
+        reason,
+        ...Number.isFinite(retryAfter) && retryAfter > 0 ? { retryAfterMs: retryAfter * 1000 } : {}
+      };
+    }
+    if (status >= 500)
+      return { result: "retry", reason, retryAfterMs: SERVER_ERROR_RETRY_MS };
+    return { result: "rejected", reason };
+  };
+  return {
+    environments,
+    async send(request) {
+      const state = states.get(request.environment);
+      if (state === undefined)
+        return { result: "unavailable", reason: "environment not configured" };
+      const body = payloadFor(request.notification);
+      if (Buffer.byteLength(body, "utf8") > PAYLOAD_MAX_BYTES) {
+        return { result: "rejected", reason: "PayloadTooLarge" };
+      }
+      return await new Promise((resolve) => {
+        let session;
+        try {
+          session = sessionFor(request.environment, state);
+        } catch {
+          resolve({ result: "retry", reason: "session unavailable" });
+          return;
+        }
+        let stream;
+        try {
+          stream = session.request({
+            ":method": "POST",
+            ":path": `/3/device/${request.token}`,
+            authorization: `bearer ${bearerFor(state)}`,
+            "apns-push-type": "alert",
+            "apns-topic": config.topic,
+            "apns-expiration": String(Math.floor(Date.now() / 1000) + EXPIRATION_SECONDS),
+            "apns-collapse-id": request.notification.collapseId,
+            "content-type": "application/json"
+          });
+        } catch {
+          resolve({ result: "retry", reason: "session unavailable" });
+          return;
+        }
+        let status = 0;
+        let responseHeaders = {};
+        const chunks = [];
+        let settled = false;
+        const finish = (verdict) => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          stream.destroy();
+          resolve(verdict);
+        };
+        const timer = setTimeout(() => finish({ result: "retry", reason: "apns timeout" }), REQUEST_TIMEOUT_MS);
+        stream.on("response", (headers) => {
+          status = Number(headers[":status"] ?? 0);
+          responseHeaders = headers;
+        });
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => {
+          let body2;
+          try {
+            body2 = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          } catch {
+            body2 = undefined;
+          }
+          finish(classify(request.environment, status, responseHeaders, body2, state));
+        });
+        stream.on("error", () => finish({ result: "retry", reason: "connection error" }));
+        stream.on("aborted", () => finish({ result: "retry", reason: "connection aborted" }));
+        stream.end(body);
+      });
+    },
+    close() {
+      for (const state of states.values())
+        state.session?.destroy();
+      states.clear();
+      return Promise.resolve();
+    }
+  };
+}
+
+// apps/server/src/relay.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { once } from "node:events";
 import { createServer } from "node:http";
 import { WebSocket, WebSocketServer } from "ws";
 
-// apps/relay/src/api.ts
+// apps/server/src/api.ts
 var SESSION_COOKIE = "__Host-pinomad-session";
 var MAX_BODY = 8 * 1024;
 var MUTATING = new Set(["POST", "PUT", "PATCH", "DELETE"]);
@@ -635,7 +848,7 @@ async function handleApiRequest(request, response, ctx) {
   deny(404, "not_found");
 }
 
-// apps/relay/src/relay.ts
+// apps/server/src/relay.ts
 var MAX_PAYLOAD = 128 * 1024;
 var MAX_BUFFERED = 64 * 1024;
 var HIGH_WATER = 1024 * 1024;
@@ -647,11 +860,12 @@ var isSendableCloseCode = (code) => code >= 1000 && code <= 1003 || code >= 1007
 var rawLength = (data) => Array.isArray(data) ? data.reduce((sum, part) => sum + part.length, 0) : data.byteLength;
 var MAX_PAIRING_PER_HOST = 4;
 var MAX_PAIRING_PER_SESSION = 2;
+var MAX_PUSH_PER_HOST = 4;
+var MAX_PUSH_TOTAL = 32;
 async function startRelay(options) {
   const publicOrigin = options.publicOrigin.replace(/\/+$/, "");
   if (publicOrigin === "")
     throw new Error("publicOrigin is required");
-  const allowedHosts = new Set(options.allowedHosts);
   const acceptTimeoutMs = options.acceptTimeoutMs ?? 1e4;
   const registerTimeoutMs = options.registerTimeoutMs ?? 1e4;
   const pingIntervalMs = options.pingIntervalMs ?? 30000;
@@ -659,6 +873,12 @@ async function startRelay(options) {
   const accounts = options.accounts;
   const trustProxy = options.trustProxy ?? false;
   const pairingTimeoutMs = options.pairingTimeoutMs ?? 1e4;
+  const apns = options.push;
+  const pushEnvironments = apns?.environments ?? [];
+  const pushPerHost = options.pushLimits?.perHost ?? MAX_PUSH_PER_HOST;
+  const pushTotal = options.pushLimits?.total ?? MAX_PUSH_TOTAL;
+  let pushInflightTotal = 0;
+  const pushInflightHosts = new Map;
   const controls = new Map;
   const pending = new Map;
   const pairingRequests = new Map;
@@ -732,6 +952,45 @@ async function startRelay(options) {
     });
   }
   const pairing = { status: pairingStatus, request: requestPairing };
+  function handlePush(socket, hostId, frame) {
+    const startedAt = Date.now();
+    const finish = (verdict) => {
+      console.log(JSON.stringify({
+        event: "push",
+        hostId,
+        environment: frame.environment,
+        result: verdict.result,
+        reason: verdict.reason,
+        ms: Date.now() - startedAt
+      }));
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(encodeRelayFrame({ t: "push-result", requestId: frame.requestId, ...verdict }));
+      }
+    };
+    if (accounts?.hasHost(hostId) !== true) {
+      finish({ result: "rejected", reason: "unauthorized" });
+      return;
+    }
+    if (apns === undefined || !pushEnvironments.includes(frame.environment)) {
+      finish({ result: "unavailable", reason: "environment not configured" });
+      return;
+    }
+    const perHost = pushInflightHosts.get(hostId) ?? 0;
+    if (perHost >= pushPerHost || pushInflightTotal >= pushTotal) {
+      finish({ result: "retry", reason: "rate_limited" });
+      return;
+    }
+    pushInflightTotal += 1;
+    pushInflightHosts.set(hostId, perHost + 1);
+    apns.send({ token: frame.token, environment: frame.environment, notification: frame.notification }).then(finish, () => finish({ result: "retry", reason: "server error" })).finally(() => {
+      pushInflightTotal -= 1;
+      const left = (pushInflightHosts.get(hostId) ?? 1) - 1;
+      if (left <= 0)
+        pushInflightHosts.delete(hostId);
+      else
+        pushInflightHosts.set(hostId, left);
+    });
+  }
   function runOp(socket, frame, noisePublicKey) {
     const answer = (reply) => socket.send(encodeRelayFrame(reply), () => socket.close(1000));
     if (accounts === undefined) {
@@ -763,8 +1022,7 @@ async function startRelay(options) {
       return;
     }
     answer({ t: "left" });
-    if (!allowedHosts.has(frame.hostId))
-      controls.get(frame.hostId)?.socket.close(RELAY_CLOSE.hostNotAllowed);
+    controls.get(frame.hostId)?.socket.close(RELAY_CLOSE.hostNotAllowed);
   }
   function onControl(socket) {
     track(socket);
@@ -785,6 +1043,15 @@ async function startRelay(options) {
           socket.close(1008, "malformed frame");
           return;
         }
+        if (answer.t === "push") {
+          handlePush(socket, hostId, answer);
+          return;
+        }
+        if (answer.t === "name") {
+          if (controls.get(hostId)?.socket === socket)
+            accounts?.renameHost(hostId, answer.name);
+          return;
+        }
         if (answer.t === "pairing" || answer.t === "pairing-refused") {
           const request = pairingRequests.get(answer.requestId);
           if (request === undefined || request.control !== socket)
@@ -826,7 +1093,7 @@ async function startRelay(options) {
         runOp(socket, frame, noisePublicKey);
         return;
       }
-      if (!allowedHosts.has(frame.hostId) && accounts?.hasHost(frame.hostId) !== true) {
+      if (accounts?.hasHost(frame.hostId) !== true) {
         socket.close(RELAY_CLOSE.hostNotAllowed);
         return;
       }
@@ -841,7 +1108,9 @@ async function startRelay(options) {
         ...frame.features === undefined ? {} : { features: frame.features }
       });
       accounts?.markHostSeen(hostId);
-      socket.send(encodeRelayFrame({ t: "registered" }));
+      if (frame.name !== undefined)
+        accounts?.renameHost(hostId, frame.name);
+      socket.send(encodeRelayFrame({ t: "registered", push: pushEnvironments, features: ["name"] }));
     });
     socket.once("close", () => {
       clearTimeout(deadline);
@@ -1016,11 +1285,12 @@ async function startRelay(options) {
       await closing;
       await new Promise((resolve) => httpServer.close(() => resolve()));
       await accounts?.close();
+      await apns?.close();
     }
   };
 }
 
-// apps/relay/src/main.ts
+// apps/server/src/main.ts
 function resolveDataDir(flag) {
   return resolve(flag ?? process.env.PINOMAD_SERVER_DATA_DIR ?? join2(homedir(), ".pinomad-server"));
 }
@@ -1045,7 +1315,7 @@ async function passwdMain(argv) {
     strict: true
   });
   if (process.stdin.isTTY) {
-    console.error("pipe the new password on stdin, e.g. `printenv NEW_PINOMAD_SERVER_PASSWORD | " + commandHint("relay") + " passwd`");
+    console.error("pipe the new password on stdin, e.g. `printenv NEW_PINOMAD_SERVER_PASSWORD | " + commandHint("server") + " passwd`");
     process.exit(1);
   }
   const dataDir = resolveDataDir(values["data-dir"]);
@@ -1067,44 +1337,40 @@ async function main(argv) {
       port: { type: "string", default: "7430" },
       listen: { type: "string", default: "127.0.0.1" },
       "public-origin": { type: "string" },
-      "allow-host": { type: "string", multiple: true },
       "data-dir": { type: "string" },
       "trust-proxy": { type: "boolean", default: false }
     }
   });
-  const allowedHosts = values["allow-host"] ?? [];
-  const bootstrapUser = process.env.PINOMAD_SERVER_USER;
-  const bootstrapPassword = process.env.PINOMAD_SERVER_PASSWORD;
-  const accountMode = allowedHosts.length === 0 || values["data-dir"] !== undefined || process.env.PINOMAD_SERVER_DATA_DIR !== undefined || bootstrapUser !== undefined || bootstrapPassword !== undefined;
   if (values["public-origin"] === undefined) {
-    console.error(`usage: ${commandHint("relay")} --public-origin ORIGIN [--allow-host HOST_ID ...] [--data-dir DIR] [--trust-proxy] [--port 7430] [--listen 127.0.0.1]
-` + `       ${commandHint("relay")} passwd [--data-dir DIR] [--user NAME]   (server stopped; new password on stdin)
+    console.error(`usage: ${commandHint("server")} --public-origin ORIGIN [--data-dir DIR] [--trust-proxy] [--port 7430] [--listen 127.0.0.1]
+` + `       ${commandHint("server")} passwd [--data-dir DIR] [--user NAME]   (server stopped; new password on stdin)
 ` + "       env: PINOMAD_SERVER_USER, PINOMAD_SERVER_PASSWORD, PINOMAD_SERVER_DATA_DIR");
     process.exit(1);
   }
-  const accounts = accountMode ? await openAccounts({
+  const accounts = await openAccounts({
     dataDir: resolveDataDir(values["data-dir"]),
-    bootstrapUser,
-    bootstrapPassword
+    bootstrapUser: process.env.PINOMAD_SERVER_USER,
+    bootstrapPassword: process.env.PINOMAD_SERVER_PASSWORD
   }).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
-  }) : undefined;
+  });
+  const apnsConfig = loadApnsConfig();
+  const apns = apnsConfig === undefined ? undefined : openApns(apnsConfig);
   const relay = await startRelay({
     port: Number(values.port),
     listenHost: values.listen,
     publicOrigin: values["public-origin"],
-    allowedHosts,
     webRoot,
     accounts,
-    trustProxy: values["trust-proxy"]
+    trustProxy: values["trust-proxy"],
+    ...apns === undefined ? {} : { push: apns }
   });
   console.log(JSON.stringify({
     event: "ready",
     url: relay.url,
     publicOrigin: values["public-origin"],
-    allowedHosts: allowedHosts.length,
-    accounts: accounts !== undefined
+    push: apns?.environments ?? []
   }));
   let stopping = false;
   const stop = () => {

package/dist/{chunk-5785kwej.js → chunk-ywmm63ks.js}

@@ -1,15 +1,13 @@
-import {
-  relayWsBase
-} from "./chunk-knaw1a9g.js";
 import {
   RELAY_CLOSE,
   decodeRelayToHost,
   encodeRelayFrame,
   relayHostId,
+  relayWsBase,
   signRelayChallenge,
   signRelayChallengeV2,
   toBase64Url
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-7qb9tq54.js";
 
 // apps/host/src/cli/server-ops.ts
 import { WebSocket } from "ws";
@@ -20,7 +18,10 @@ async function probeAccounts(origin, fetchImpl = fallbackFetch) {
   const timeout = new AbortController;
   const timer = setTimeout(() => timeout.abort(), 5000);
   try {
-    const response = await fetchImpl(`${origin.replace(/\/+$/, "")}/api/me`, { signal: timeout.signal });
+    const response = await fetchImpl(`${origin.replace(/\/+$/, "")}/api/me`, {
+      signal: timeout.signal,
+      redirect: "manual"
+    });
     if (response.status === 401)
       return "enabled";
     if (response.status === 200) {
@@ -48,7 +49,8 @@ function isSecureServerOrigin(origin) {
     return false;
   }
   const host = url.hostname;
-  const loopback = host === "localhost" || host.endsWith(".localhost") || host.startsWith("127.") || host === "::1" || host === "[::1]";
+  const ipv4Loopback = /^127(?:\.\d{1,3}){3}$/.test(host);
+  const loopback = host === "localhost" || host.endsWith(".localhost") || ipv4Loopback || host === "::1" || host === "[::1]";
   return url.protocol === "https:" || url.protocol === "http:" && loopback;
 }
 
@@ -118,7 +120,7 @@ async function runServerOperation(options) {
         finish(() => reject(new Error(`${origin} ignored the operation — the server is too old for accounts; upgrade it first`)));
         return;
       }
-      if (frame.t === "incoming" || frame.t === "pairing-request")
+      if (frame.t === "incoming" || frame.t === "pairing-request" || frame.t === "push-result")
         return;
       finish(() => resolve(frame));
     });

package/dist/chunk-znhn8af7.js

@@ -0,0 +1,33 @@
+// packages/protocol/src/settings.ts
+var HOST_SETTING_KEY_SET = {
+  defaultModel: true,
+  defaultThinkingLevel: true,
+  steeringMode: true,
+  followUpMode: true,
+  acceptAccountDevices: true,
+  hostName: true
+};
+var HOST_SETTING_KEYS = Object.keys(HOST_SETTING_KEY_SET);
+var THINKING_LEVEL_KEYS = { off: true, minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
+var THINKING_LEVELS = Object.keys(THINKING_LEVEL_KEYS);
+var isThinkingLevel = (value) => typeof value === "string" && Object.prototype.hasOwnProperty.call(THINKING_LEVEL_KEYS, value);
+var isQueueMode = (value) => value === "all" || value === "one-at-a-time";
+var HOST_NAME_FALLBACK = "pinomad";
+var HOST_NAME_MAX_UNITS = 64;
+var isHostNameControl = (code) => code < 32 || code >= 127 && code <= 159;
+function cleanHostName(name) {
+  let cleaned = name;
+  for (;; ) {
+    const local = cleaned.endsWith(".local") ? cleaned.slice(0, -".local".length) : cleaned;
+    const next = [...local.trim()].filter((c) => !isHostNameControl(c.codePointAt(0))).join("").slice(0, HOST_NAME_MAX_UNITS);
+    if (next === cleaned)
+      return next;
+    cleaned = next;
+  }
+}
+function normalizeHostName(name) {
+  const cleaned = cleanHostName(name);
+  return cleaned === "" ? HOST_NAME_FALLBACK : cleaned;
+}
+
+export { HOST_SETTING_KEYS, THINKING_LEVELS, isThinkingLevel, isQueueMode, HOST_NAME_MAX_UNITS, cleanHostName, normalizeHostName };

package/dist/pinomad.js

@@ -1,39 +1,53 @@
 #!/usr/bin/env node
+import {
+  isParseArgsError,
+  reportParseArgsError
+} from "./chunk-kzbzacz9.js";
 import {
   packagedVersion
-} from "./chunk-fgx2sh7d.js";
+} from "./chunk-c8nxym2z.js";
 import {
   __require
 } from "./chunk-df32avw6.js";
 
 // apps/cli/src/pinomad.ts
 var COMMANDS = {
-  host: () => import("./chunk-z5pmcscx.js"),
-  relay: () => import("./chunk-vw5yb5pd.js"),
-  service: () => import("./chunk-prhvksh3.js"),
-  upgrade: () => import("./chunk-17p6bfvy.js"),
-  link: () => import("./chunk-n73t5xzw.js"),
-  pair: () => import("./chunk-d4y99pfy.js"),
-  "relay-id": () => import("./chunk-xrvmnymc.js"),
-  join: () => import("./chunk-b3f0ced1.js"),
-  leave: () => import("./chunk-xhwkx9bd.js")
+  host: () => import("./chunk-4btj08we.js"),
+  server: () => import("./chunk-wqvp1fwh.js"),
+  relay: () => import("./chunk-wqvp1fwh.js"),
+  service: () => import("./chunk-ggb1taqy.js"),
+  upgrade: () => import("./chunk-jn7y815x.js"),
+  link: () => import("./chunk-367n9je8.js"),
+  pair: () => import("./chunk-7s1f4z4g.js"),
+  join: () => import("./chunk-k2s1hfq5.js"),
+  leave: () => import("./chunk-3dnnaz4j.js")
 };
-var USAGE = `pinomad — PiNomad host, relay, and utilities
+var USAGE = `pinomad — PiNomad host, server, and utilities
 
 usage: pinomad <command> [args…]
 
-  host [host args…]                    run the host in the foreground
-  relay --public-origin O [--allow-host H…] [--data-dir D] [--trust-proxy]   run the server
-  relay passwd [--data-dir D] [--user U]   change the account password (stdin)
+  host [--data-dir DIR] [--port 7420] [--project DIR]…   run the host in the foreground
+  host --remote-port PORT [--public-url URL]   remote access, LAN (ADR-0008)
+  host --relay URL   remote access via relay (ADR-0015)
+  host --faux "answer" [--faux-tps 40]   no real model, for tests
+  server --public-origin O [--data-dir D] [--trust-proxy]   run the server
+  server passwd [--data-dir D] [--user U]   change the account password (stdin)
+  relay …                              old name of server
   service install|uninstall|status|restart|logs   user-level host service
   upgrade [--force] [address flags]    upgrade the package and restart the service
   link [--data-dir D|--url U …]        print the browser link
   pair [--data-dir D|--url U …]        print a pairing QR
-  relay-id [--data-dir D]              print this host's relay id (for --allow-host)
   join <origin> <token> [--data-dir D] join this host to a server account
   leave [--data-dir D]                 leave the server account
   --version, -v                        print the version
 `;
+function usageFor(command) {
+  const rows = USAGE.split(`
+`).filter((line) => line.startsWith(`  ${command} `));
+  return `usage: pinomad ${command} [args…]
+${rows.join(`
+`)}`;
+}
 async function main(argv) {
   const [command, ...rest] = argv;
   if (command === "--version" || command === "-v") {
@@ -51,7 +65,17 @@ async function main(argv) {
     process.exitCode = 1;
     return;
   }
-  await (await load()).main(rest);
+  if (rest.includes("--help") || rest.includes("-h")) {
+    console.log(usageFor(command));
+    return;
+  }
+  try {
+    await (await load()).main(rest);
+  } catch (error) {
+    if (!isParseArgsError(error))
+      throw error;
+    reportParseArgsError(`pinomad ${command}`, error);
+  }
 }
 if (__require.main == __require.module)
   await main(process.argv.slice(2));